pub struct Box<T, A = Global>(Unique<T>, A)
where
A: Allocator,
T: ?Sized;Expand description
A pointer type that uniquely owns a heap allocation of type T.
See the module-level documentation for more.
Tuple Fields§
§0: Unique<T>§1: AImplementations§
source§impl<T> Box<T>
impl<T> Box<T>
1.0.0 · sourcepub fn new(x: T) -> Box<T>
pub fn new(x: T) -> Box<T>
Allocates memory on the heap and then places x into it.
This doesn’t actually allocate if T is zero-sized.
§Examples
let five = Box::new(5);sourcepub fn new_uninit() -> Box<MaybeUninit<T>>
🔬This is a nightly-only experimental API. (new_uninit)
pub fn new_uninit() -> Box<MaybeUninit<T>>
new_uninit)Constructs a new box with uninitialized contents.
§Examples
#![feature(new_uninit)]
let mut five = Box::<u32>::new_uninit();
let five = unsafe {
// Deferred initialization:
five.as_mut_ptr().write(5);
five.assume_init()
};
assert_eq!(*five, 5)sourcepub fn new_zeroed() -> Box<MaybeUninit<T>>
🔬This is a nightly-only experimental API. (new_uninit)
pub fn new_zeroed() -> Box<MaybeUninit<T>>
new_uninit)Constructs a new Box with uninitialized contents, with the memory
being filled with 0 bytes.
See MaybeUninit::zeroed for examples of correct and incorrect usage
of this method.
§Examples
#![feature(new_uninit)]
let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };
assert_eq!(*zero, 0)1.33.0 · sourcepub fn pin(x: T) -> Pin<Box<T>>
pub fn pin(x: T) -> Pin<Box<T>>
Constructs a new Pin<Box<T>>. If T does not implement Unpin, then
x will be pinned in memory and unable to be moved.
Constructing and pinning of the Box can also be done in two steps: Box::pin(x)
does the same as Box::into_pin(Box::new(x)). Consider using
into_pin if you already have a Box<T>, or if you want to
construct a (pinned) Box in a different way than with Box::new.
sourcepub fn try_new(x: T) -> Result<Box<T>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api)
pub fn try_new(x: T) -> Result<Box<T>, AllocError>
allocator_api)Allocates memory on the heap then places x into it,
returning an error if the allocation fails
This doesn’t actually allocate if T is zero-sized.
§Examples
#![feature(allocator_api)]
let five = Box::try_new(5)?;sourcepub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api)
pub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>
allocator_api)Constructs a new box with uninitialized contents on the heap, returning an error if the allocation fails
§Examples
#![feature(allocator_api, new_uninit)]
let mut five = Box::<u32>::try_new_uninit()?;
let five = unsafe {
// Deferred initialization:
five.as_mut_ptr().write(5);
five.assume_init()
};
assert_eq!(*five, 5);sourcepub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api)
pub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>
allocator_api)Constructs a new Box with uninitialized contents, with the memory
being filled with 0 bytes on the heap
See MaybeUninit::zeroed for examples of correct and incorrect usage
of this method.
§Examples
#![feature(allocator_api, new_uninit)]
let zero = Box::<u32>::try_new_zeroed()?;
let zero = unsafe { zero.assume_init() };
assert_eq!(*zero, 0);source§impl<T, A> Box<T, A>where
A: Allocator,
impl<T, A> Box<T, A>where
A: Allocator,
sourcepub fn new_in(x: T, alloc: A) -> Box<T, A>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api)
pub fn new_in(x: T, alloc: A) -> Box<T, A>where
A: Allocator,
allocator_api)Allocates memory in the given allocator then places x into it.
This doesn’t actually allocate if T is zero-sized.
§Examples
#![feature(allocator_api)]
use std::alloc::System;
let five = Box::new_in(5, System);sourcepub fn try_new_in(x: T, alloc: A) -> Result<Box<T, A>, AllocError>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api)
pub fn try_new_in(x: T, alloc: A) -> Result<Box<T, A>, AllocError>where
A: Allocator,
allocator_api)Allocates memory in the given allocator then places x into it,
returning an error if the allocation fails
This doesn’t actually allocate if T is zero-sized.
§Examples
#![feature(allocator_api)]
use std::alloc::System;
let five = Box::try_new_in(5, System)?;sourcepub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api)
pub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>where
A: Allocator,
allocator_api)Constructs a new box with uninitialized contents in the provided allocator.
§Examples
#![feature(allocator_api, new_uninit)]
use std::alloc::System;
let mut five = Box::<u32, _>::new_uninit_in(System);
let five = unsafe {
// Deferred initialization:
five.as_mut_ptr().write(5);
five.assume_init()
};
assert_eq!(*five, 5)sourcepub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api)
pub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where
A: Allocator,
allocator_api)Constructs a new box with uninitialized contents in the provided allocator, returning an error if the allocation fails
§Examples
#![feature(allocator_api, new_uninit)]
use std::alloc::System;
let mut five = Box::<u32, _>::try_new_uninit_in(System)?;
let five = unsafe {
// Deferred initialization:
five.as_mut_ptr().write(5);
five.assume_init()
};
assert_eq!(*five, 5);sourcepub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api)
pub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>where
A: Allocator,
allocator_api)Constructs a new Box with uninitialized contents, with the memory
being filled with 0 bytes in the provided allocator.
See MaybeUninit::zeroed for examples of correct and incorrect usage
of this method.
§Examples
#![feature(allocator_api, new_uninit)]
use std::alloc::System;
let zero = Box::<u32, _>::new_zeroed_in(System);
let zero = unsafe { zero.assume_init() };
assert_eq!(*zero, 0)sourcepub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where
A: Allocator,
🔬This is a nightly-only experimental API. (allocator_api)
pub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where
A: Allocator,
allocator_api)Constructs a new Box with uninitialized contents, with the memory
being filled with 0 bytes in the provided allocator,
returning an error if the allocation fails,
See MaybeUninit::zeroed for examples of correct and incorrect usage
of this method.
§Examples
#![feature(allocator_api, new_uninit)]
use std::alloc::System;
let zero = Box::<u32, _>::try_new_zeroed_in(System)?;
let zero = unsafe { zero.assume_init() };
assert_eq!(*zero, 0);sourcepub fn pin_in(x: T, alloc: A) -> Pin<Box<T, A>>where
A: 'static + Allocator,
🔬This is a nightly-only experimental API. (allocator_api)
pub fn pin_in(x: T, alloc: A) -> Pin<Box<T, A>>where
A: 'static + Allocator,
allocator_api)Constructs a new Pin<Box<T, A>>. If T does not implement Unpin, then
x will be pinned in memory and unable to be moved.
Constructing and pinning of the Box can also be done in two steps: Box::pin_in(x, alloc)
does the same as Box::into_pin(Box::new_in(x, alloc)). Consider using
into_pin if you already have a Box<T, A>, or if you want to
construct a (pinned) Box in a different way than with Box::new_in.
sourcepub fn into_boxed_slice(boxed: Box<T, A>) -> Box<[T], A>
🔬This is a nightly-only experimental API. (box_into_boxed_slice)
pub fn into_boxed_slice(boxed: Box<T, A>) -> Box<[T], A>
box_into_boxed_slice)Converts a Box<T> into a Box<[T]>
This conversion does not allocate on the heap and happens in place.
sourcepub fn into_inner(boxed: Box<T, A>) -> T
🔬This is a nightly-only experimental API. (box_into_inner)
pub fn into_inner(boxed: Box<T, A>) -> T
box_into_inner)Consumes the Box, returning the wrapped value.
§Examples
#![feature(box_into_inner)]
let c = Box::new(5);
assert_eq!(Box::into_inner(c), 5);source§impl<T> Box<[T]>
impl<T> Box<[T]>
sourcepub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>]>
🔬This is a nightly-only experimental API. (new_uninit)
pub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>]>
new_uninit)Constructs a new boxed slice with uninitialized contents.
§Examples
#![feature(new_uninit)]
let mut values = Box::<[u32]>::new_uninit_slice(3);
let values = unsafe {
// Deferred initialization:
values[0].as_mut_ptr().write(1);
values[1].as_mut_ptr().write(2);
values[2].as_mut_ptr().write(3);
values.assume_init()
};
assert_eq!(*values, [1, 2, 3])sourcepub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>]>
🔬This is a nightly-only experimental API. (new_uninit)
pub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>]>
new_uninit)Constructs a new boxed slice with uninitialized contents, with the memory
being filled with 0 bytes.
See MaybeUninit::zeroed for examples of correct and incorrect usage
of this method.
§Examples
#![feature(new_uninit)]
let values = Box::<[u32]>::new_zeroed_slice(3);
let values = unsafe { values.assume_init() };
assert_eq!(*values, [0, 0, 0])sourcepub fn try_new_uninit_slice(
len: usize,
) -> Result<Box<[MaybeUninit<T>]>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api)
pub fn try_new_uninit_slice( len: usize, ) -> Result<Box<[MaybeUninit<T>]>, AllocError>
allocator_api)Constructs a new boxed slice with uninitialized contents. Returns an error if the allocation fails
§Examples
#![feature(allocator_api, new_uninit)]
let mut values = Box::<[u32]>::try_new_uninit_slice(3)?;
let values = unsafe {
// Deferred initialization:
values[0].as_mut_ptr().write(1);
values[1].as_mut_ptr().write(2);
values[2].as_mut_ptr().write(3);
values.assume_init()
};
assert_eq!(*values, [1, 2, 3]);sourcepub fn try_new_zeroed_slice(
len: usize,
) -> Result<Box<[MaybeUninit<T>]>, AllocError>
🔬This is a nightly-only experimental API. (allocator_api)
pub fn try_new_zeroed_slice( len: usize, ) -> Result<Box<[MaybeUninit<T>]>, AllocError>
allocator_api)Constructs a new boxed slice with uninitialized contents, with the memory
being filled with 0 bytes. Returns an error if the allocation fails
See MaybeUninit::zeroed for examples of correct and incorrect usage
of this method.
§Examples
#![feature(allocator_api, new_uninit)]
let values = Box::<[u32]>::try_new_zeroed_slice(3)?;
let values = unsafe { values.assume_init() };
assert_eq!(*values, [0, 0, 0]);source§impl<T, A> Box<[T], A>where
A: Allocator,
impl<T, A> Box<[T], A>where
A: Allocator,
sourcepub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>
🔬This is a nightly-only experimental API. (allocator_api)
pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>
allocator_api)Constructs a new boxed slice with uninitialized contents in the provided allocator.
§Examples
#![feature(allocator_api, new_uninit)]
use std::alloc::System;
let mut values = Box::<[u32], _>::new_uninit_slice_in(3, System);
let values = unsafe {
// Deferred initialization:
values[0].as_mut_ptr().write(1);
values[1].as_mut_ptr().write(2);
values[2].as_mut_ptr().write(3);
values.assume_init()
};
assert_eq!(*values, [1, 2, 3])sourcepub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>
🔬This is a nightly-only experimental API. (allocator_api)
pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>
allocator_api)Constructs a new boxed slice with uninitialized contents in the provided allocator,
with the memory being filled with 0 bytes.
See MaybeUninit::zeroed for examples of correct and incorrect usage
of this method.
§Examples
#![feature(allocator_api, new_uninit)]
use std::alloc::System;
let values = Box::<[u32], _>::new_zeroed_slice_in(3, System);
let values = unsafe { values.assume_init() };
assert_eq!(*values, [0, 0, 0])source§impl<T, A> Box<MaybeUninit<T>, A>where
A: Allocator,
impl<T, A> Box<MaybeUninit<T>, A>where
A: Allocator,
sourcepub unsafe fn assume_init(self) -> Box<T, A>
🔬This is a nightly-only experimental API. (new_uninit)
pub unsafe fn assume_init(self) -> Box<T, A>
new_uninit)Converts to Box<T, A>.
§Safety
As with MaybeUninit::assume_init,
it is up to the caller to guarantee that the value
really is in an initialized state.
Calling this when the content is not yet fully initialized
causes immediate undefined behavior.
§Examples
#![feature(new_uninit)]
let mut five = Box::<u32>::new_uninit();
let five: Box<u32> = unsafe {
// Deferred initialization:
five.as_mut_ptr().write(5);
five.assume_init()
};
assert_eq!(*five, 5)sourcepub fn write(boxed: Box<MaybeUninit<T>, A>, value: T) -> Box<T, A>
🔬This is a nightly-only experimental API. (new_uninit)
pub fn write(boxed: Box<MaybeUninit<T>, A>, value: T) -> Box<T, A>
new_uninit)Writes the value and converts to Box<T, A>.
This method converts the box similarly to Box::assume_init but
writes value into it before conversion thus guaranteeing safety.
In some scenarios use of this method may improve performance because
the compiler may be able to optimize copying from stack.
§Examples
#![feature(new_uninit)]
let big_box = Box::<[usize; 1024]>::new_uninit();
let mut array = [0; 1024];
for (i, place) in array.iter_mut().enumerate() {
*place = i;
}
// The optimizer may be able to elide this copy, so previous code writes
// to heap directly.
let big_box = Box::write(big_box, array);
for (i, x) in big_box.iter().enumerate() {
assert_eq!(*x, i);
}source§impl<T, A> Box<[MaybeUninit<T>], A>where
A: Allocator,
impl<T, A> Box<[MaybeUninit<T>], A>where
A: Allocator,
sourcepub unsafe fn assume_init(self) -> Box<[T], A>
🔬This is a nightly-only experimental API. (new_uninit)
pub unsafe fn assume_init(self) -> Box<[T], A>
new_uninit)Converts to Box<[T], A>.
§Safety
As with MaybeUninit::assume_init,
it is up to the caller to guarantee that the values
really are in an initialized state.
Calling this when the content is not yet fully initialized
causes immediate undefined behavior.
§Examples
#![feature(new_uninit)]
let mut values = Box::<[u32]>::new_uninit_slice(3);
let values = unsafe {
// Deferred initialization:
values[0].as_mut_ptr().write(1);
values[1].as_mut_ptr().write(2);
values[2].as_mut_ptr().write(3);
values.assume_init()
};
assert_eq!(*values, [1, 2, 3])source§impl<T> Box<T>where
T: ?Sized,
impl<T> Box<T>where
T: ?Sized,
1.4.0 · sourcepub unsafe fn from_raw(raw: *mut T) -> Box<T>
pub unsafe fn from_raw(raw: *mut T) -> Box<T>
Constructs a box from a raw pointer.
After calling this function, the raw pointer is owned by the
resulting Box. Specifically, the Box destructor will call
the destructor of T and free the allocated memory. For this
to be safe, the memory must have been allocated in accordance
with the memory layout used by Box .
§Safety
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
The safety conditions are described in the memory layout section.
§Examples
Recreate a Box which was previously converted to a raw pointer
using Box::into_raw:
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };Manually create a Box from scratch by using the global allocator:
use std::alloc::{alloc, Layout};
unsafe {
let ptr = alloc(Layout::new::<i32>()) as *mut i32;
// In general .write is required to avoid attempting to destruct
// the (uninitialized) previous contents of `ptr`, though for this
// simple example `*ptr = 5` would have worked as well.
ptr.write(5);
let x = Box::from_raw(ptr);
}source§impl<T, A> Box<T, A>
impl<T, A> Box<T, A>
sourcepub const unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>
🔬This is a nightly-only experimental API. (allocator_api)
pub const unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>
allocator_api)Constructs a box from a raw pointer in the given allocator.
After calling this function, the raw pointer is owned by the
resulting Box. Specifically, the Box destructor will call
the destructor of T and free the allocated memory. For this
to be safe, the memory must have been allocated in accordance
with the memory layout used by Box .
§Safety
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
§Examples
Recreate a Box which was previously converted to a raw pointer
using Box::into_raw_with_allocator:
#![feature(allocator_api)]
use std::alloc::System;
let x = Box::new_in(5, System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };Manually create a Box from scratch by using the system allocator:
#![feature(allocator_api, slice_ptr_get)]
use std::alloc::{Allocator, Layout, System};
unsafe {
let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;
// In general .write is required to avoid attempting to destruct
// the (uninitialized) previous contents of `ptr`, though for this
// simple example `*ptr = 5` would have worked as well.
ptr.write(5);
let x = Box::from_raw_in(ptr, System);
}1.4.0 · sourcepub fn into_raw(b: Box<T, A>) -> *mut T
pub fn into_raw(b: Box<T, A>) -> *mut T
Consumes the Box, returning a wrapped raw pointer.
The pointer will be properly aligned and non-null.
After calling this function, the caller is responsible for the
memory previously managed by the Box. In particular, the
caller should properly destroy T and release the memory, taking
into account the memory layout used by Box. The easiest way to
do this is to convert the raw pointer back into a Box with the
Box::from_raw function, allowing the Box destructor to perform
the cleanup.
Note: this is an associated function, which means that you have
to call it as Box::into_raw(b) instead of b.into_raw(). This
is so that there is no conflict with a method on the inner type.
§Examples
Converting the raw pointer back into a Box with Box::from_raw
for automatic cleanup:
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };Manual cleanup by explicitly running the destructor and deallocating the memory:
use std::alloc::{dealloc, Layout};
use std::ptr;
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
ptr::drop_in_place(ptr);
dealloc(ptr as *mut u8, Layout::new::<String>());
}Note: This is equivalent to the following:
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
drop(Box::from_raw(ptr));
}sourcepub fn into_raw_with_allocator(b: Box<T, A>) -> (*mut T, A)
🔬This is a nightly-only experimental API. (allocator_api)
pub fn into_raw_with_allocator(b: Box<T, A>) -> (*mut T, A)
allocator_api)Consumes the Box, returning a wrapped raw pointer and the allocator.
The pointer will be properly aligned and non-null.
After calling this function, the caller is responsible for the
memory previously managed by the Box. In particular, the
caller should properly destroy T and release the memory, taking
into account the memory layout used by Box. The easiest way to
do this is to convert the raw pointer back into a Box with the
Box::from_raw_in function, allowing the Box destructor to perform
the cleanup.
Note: this is an associated function, which means that you have
to call it as Box::into_raw_with_allocator(b) instead of b.into_raw_with_allocator(). This
is so that there is no conflict with a method on the inner type.
§Examples
Converting the raw pointer back into a Box with Box::from_raw_in
for automatic cleanup:
#![feature(allocator_api)]
use std::alloc::System;
let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };Manual cleanup by explicitly running the destructor and deallocating the memory:
#![feature(allocator_api)]
use std::alloc::{Allocator, Layout, System};
use std::ptr::{self, NonNull};
let x = Box::new_in(String::from("Hello"), System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
unsafe {
ptr::drop_in_place(ptr);
let non_null = NonNull::new_unchecked(ptr);
alloc.deallocate(non_null.cast(), Layout::new::<String>());
}sourcepub const fn allocator(b: &Box<T, A>) -> &A
🔬This is a nightly-only experimental API. (allocator_api)
pub const fn allocator(b: &Box<T, A>) -> &A
allocator_api)Returns a reference to the underlying allocator.
Note: this is an associated function, which means that you have
to call it as Box::allocator(&b) instead of b.allocator(). This
is so that there is no conflict with a method on the inner type.
1.26.0 · sourcepub fn leak<'a>(b: Box<T, A>) -> &'a mut Twhere
A: 'a,
pub fn leak<'a>(b: Box<T, A>) -> &'a mut Twhere
A: 'a,
Consumes and leaks the Box, returning a mutable reference,
&'a mut T. Note that the type T must outlive the chosen lifetime
'a. If the type has only static references, or none at all, then this
may be chosen to be 'static.
This function is mainly useful for data that lives for the remainder of
the program’s life. Dropping the returned reference will cause a memory
leak. If this is not acceptable, the reference should first be wrapped
with the Box::from_raw function producing a Box. This Box can
then be dropped which will properly destroy T and release the
allocated memory.
Note: this is an associated function, which means that you have
to call it as Box::leak(b) instead of b.leak(). This
is so that there is no conflict with a method on the inner type.
§Examples
Simple usage:
let x = Box::new(41);
let static_ref: &'static mut usize = Box::leak(x);
*static_ref += 1;
assert_eq!(*static_ref, 42);Unsized data:
let x = vec![1, 2, 3].into_boxed_slice();
let static_ref = Box::leak(x);
static_ref[0] = 4;
assert_eq!(*static_ref, [4, 2, 3]);1.63.0 (const: unstable) · sourcepub fn into_pin(boxed: Box<T, A>) -> Pin<Box<T, A>>where
A: 'static,
pub fn into_pin(boxed: Box<T, A>) -> Pin<Box<T, A>>where
A: 'static,
Converts a Box<T> into a Pin<Box<T>>. If T does not implement Unpin, then
*boxed will be pinned in memory and unable to be moved.
This conversion does not allocate on the heap and happens in place.
This is also available via From.
Constructing and pinning a Box with Box::into_pin(Box::new(x))
can also be written more concisely using Box::pin(x).
This into_pin method is useful if you already have a Box<T>, or you are
constructing a (pinned) Box in a different way than with Box::new.
§Notes
It’s not recommended that crates add an impl like From<Box<T>> for Pin<T>,
as it’ll introduce an ambiguity when calling Pin::from.
A demonstration of such a poor impl is shown below.
struct Foo; // A type defined in this crate.
impl From<Box<()>> for Pin<Foo> {
fn from(_: Box<()>) -> Pin<Foo> {
Pin::new(Foo)
}
}
let foo = Box::new(());
let bar = Pin::from(foo);source§impl<A> Box<dyn Any, A>where
A: Allocator,
impl<A> Box<dyn Any, A>where
A: Allocator,
1.0.0 · sourcepub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any, A>>where
T: Any,
pub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any, A>>where
T: Any,
Attempt to downcast the box to a concrete type.
§Examples
use std::any::Any;
fn print_if_string(value: Box<dyn Any>) {
if let Ok(string) = value.downcast::<String>() {
println!("String ({}): {}", string.len(), string);
}
}
let my_string = "Hello World".to_string();
print_if_string(Box::new(my_string));
print_if_string(Box::new(0i8));sourcepub unsafe fn downcast_unchecked<T>(self) -> Box<T, A>where
T: Any,
🔬This is a nightly-only experimental API. (downcast_unchecked)
pub unsafe fn downcast_unchecked<T>(self) -> Box<T, A>where
T: Any,
downcast_unchecked)Downcasts the box to a concrete type.
For a safe alternative see downcast.
§Examples
#![feature(downcast_unchecked)]
use std::any::Any;
let x: Box<dyn Any> = Box::new(1_usize);
unsafe {
assert_eq!(*x.downcast_unchecked::<usize>(), 1);
}§Safety
The contained value must be of type T. Calling this method
with the incorrect type is undefined behavior.
source§impl<A> Box<dyn Any + Send, A>where
A: Allocator,
impl<A> Box<dyn Any + Send, A>where
A: Allocator,
1.0.0 · sourcepub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + Send, A>>where
T: Any,
pub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + Send, A>>where
T: Any,
Attempt to downcast the box to a concrete type.
§Examples
use std::any::Any;
fn print_if_string(value: Box<dyn Any + Send>) {
if let Ok(string) = value.downcast::<String>() {
println!("String ({}): {}", string.len(), string);
}
}
let my_string = "Hello World".to_string();
print_if_string(Box::new(my_string));
print_if_string(Box::new(0i8));sourcepub unsafe fn downcast_unchecked<T>(self) -> Box<T, A>where
T: Any,
🔬This is a nightly-only experimental API. (downcast_unchecked)
pub unsafe fn downcast_unchecked<T>(self) -> Box<T, A>where
T: Any,
downcast_unchecked)Downcasts the box to a concrete type.
For a safe alternative see downcast.
§Examples
#![feature(downcast_unchecked)]
use std::any::Any;
let x: Box<dyn Any + Send> = Box::new(1_usize);
unsafe {
assert_eq!(*x.downcast_unchecked::<usize>(), 1);
}§Safety
The contained value must be of type T. Calling this method
with the incorrect type is undefined behavior.
source§impl<A> Box<dyn Any + Send + Sync, A>where
A: Allocator,
impl<A> Box<dyn Any + Send + Sync, A>where
A: Allocator,
1.51.0 · sourcepub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + Send + Sync, A>>where
T: Any,
pub fn downcast<T>(self) -> Result<Box<T, A>, Box<dyn Any + Send + Sync, A>>where
T: Any,
Attempt to downcast the box to a concrete type.
§Examples
use std::any::Any;
fn print_if_string(value: Box<dyn Any + Send + Sync>) {
if let Ok(string) = value.downcast::<String>() {
println!("String ({}): {}", string.len(), string);
}
}
let my_string = "Hello World".to_string();
print_if_string(Box::new(my_string));
print_if_string(Box::new(0i8));sourcepub unsafe fn downcast_unchecked<T>(self) -> Box<T, A>where
T: Any,
🔬This is a nightly-only experimental API. (downcast_unchecked)
pub unsafe fn downcast_unchecked<T>(self) -> Box<T, A>where
T: Any,
downcast_unchecked)Downcasts the box to a concrete type.
For a safe alternative see downcast.
§Examples
#![feature(downcast_unchecked)]
use std::any::Any;
let x: Box<dyn Any + Send + Sync> = Box::new(1_usize);
unsafe {
assert_eq!(*x.downcast_unchecked::<usize>(), 1);
}§Safety
The contained value must be of type T. Calling this method
with the incorrect type is undefined behavior.
Trait Implementations§
1.64.0 · source§impl<T> AsFd for Box<T>
impl<T> AsFd for Box<T>
source§fn as_fd(&self) -> BorrowedFd<'_>
fn as_fd(&self) -> BorrowedFd<'_>
§impl<T> AsyncBufRead for Box<T>
impl<T> AsyncBufRead for Box<T>
§impl<T> AsyncBufRead for Box<T>
impl<T> AsyncBufRead for Box<T>
source§impl<Args, F, A> AsyncFn<Args> for Box<F, A>
impl<Args, F, A> AsyncFn<Args> for Box<F, A>
source§extern "rust-call" fn async_call(
&self,
args: Args,
) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
extern "rust-call" fn async_call( &self, args: Args, ) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
async_fn_traits)AsyncFn, returning a future which may borrow from the called closure.source§impl<Args, F, A> AsyncFnMut<Args> for Box<F, A>
impl<Args, F, A> AsyncFnMut<Args> for Box<F, A>
§type CallRefFuture<'a> = <F as AsyncFnMut<Args>>::CallRefFuture<'a>
where
Box<F, A>: 'a
type CallRefFuture<'a> = <F as AsyncFnMut<Args>>::CallRefFuture<'a> where Box<F, A>: 'a
async_fn_traits)AsyncFnMut::async_call_mut and AsyncFn::async_call.source§extern "rust-call" fn async_call_mut(
&mut self,
args: Args,
) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
extern "rust-call" fn async_call_mut( &mut self, args: Args, ) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
async_fn_traits)AsyncFnMut, returning a future which may borrow from the called closure.source§impl<Args, F, A> AsyncFnOnce<Args> for Box<F, A>
impl<Args, F, A> AsyncFnOnce<Args> for Box<F, A>
§type Output = <F as AsyncFnOnce<Args>>::Output
type Output = <F as AsyncFnOnce<Args>>::Output
async_fn_traits)§type CallOnceFuture = <F as AsyncFnOnce<Args>>::CallOnceFuture
type CallOnceFuture = <F as AsyncFnOnce<Args>>::CallOnceFuture
async_fn_traits)AsyncFnOnce::async_call_once.source§extern "rust-call" fn async_call_once(
self,
args: Args,
) -> <Box<F, A> as AsyncFnOnce<Args>>::CallOnceFuture
extern "rust-call" fn async_call_once( self, args: Args, ) -> <Box<F, A> as AsyncFnOnce<Args>>::CallOnceFuture
async_fn_traits)AsyncFnOnce, returning a future which may move out of the called closure.source§impl<S> AsyncIterator for Box<S>
impl<S> AsyncIterator for Box<S>
§type Item = <S as AsyncIterator>::Item
type Item = <S as AsyncIterator>::Item
async_iterator)source§fn poll_next(
self: Pin<&mut Box<S>>,
cx: &mut Context<'_>,
) -> Poll<Option<<Box<S> as AsyncIterator>::Item>>
fn poll_next( self: Pin<&mut Box<S>>, cx: &mut Context<'_>, ) -> Poll<Option<<Box<S> as AsyncIterator>::Item>>
async_iterator)None if the async iterator is exhausted. Read more§impl<T> AsyncRead for Box<T>
impl<T> AsyncRead for Box<T>
§impl<T> AsyncWrite for Box<T>
impl<T> AsyncWrite for Box<T>
§fn poll_write(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<Result<usize, Error>>
fn poll_write( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>
buf into the object. Read more§fn poll_write_vectored(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>],
) -> Poll<Result<usize, Error>>
fn poll_write_vectored( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>
bufs into the object using vectored
IO operations. Read more§impl<T> AsyncWrite for Box<T>
impl<T> AsyncWrite for Box<T>
§fn poll_write(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<Result<usize, Error>>
fn poll_write( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>
buf into the object. Read more§fn poll_write_vectored(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>],
) -> Poll<Result<usize, Error>>
fn poll_write_vectored( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>
poll_write, except that it writes from a slice of buffers. Read more§fn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
poll_write_vectored
implementation. Read more§impl<T> BitSet for Box<[T]>
impl<T> BitSet for Box<[T]>
§fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Box<[T]>
fn bit_cond(&mut self, bit: usize, value: bool) -> &mut Box<[T]>
§fn bit_disjoint(&self, rhs: &Box<[T]>) -> bool
fn bit_disjoint(&self, rhs: &Box<[T]>) -> bool
§fn bit_subset(&self, rhs: &Box<[T]>) -> bool
fn bit_subset(&self, rhs: &Box<[T]>) -> bool
§fn bit_superset(&self, rhs: &Box<[T]>) -> bool
fn bit_superset(&self, rhs: &Box<[T]>) -> bool
§impl<T> Body for Box<T>
impl<T> Body for Box<T>
source§impl<T> Body for Box<T>
impl<T> Body for Box<T>
source§fn poll_data(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
) -> Poll<Option<Result<<Box<T> as Body>::Data, <Box<T> as Body>::Error>>>
fn poll_data( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, ) -> Poll<Option<Result<<Box<T> as Body>::Data, <Box<T> as Body>::Error>>>
source§fn poll_trailers(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
) -> Poll<Result<Option<HeaderMap>, <Box<T> as Body>::Error>>
fn poll_trailers( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, ) -> Poll<Result<Option<HeaderMap>, <Box<T> as Body>::Error>>
HeaderMap of trailers. Read moresource§fn is_end_stream(&self) -> bool
fn is_end_stream(&self) -> bool
true when the end of stream has been reached. Read moresource§fn size_hint(&self) -> SizeHint
fn size_hint(&self) -> SizeHint
source§fn data(&mut self) -> Data<'_, Self> ⓘ
fn data(&mut self) -> Data<'_, Self> ⓘ
source§fn trailers(&mut self) -> Trailers<'_, Self> ⓘ
fn trailers(&mut self) -> Trailers<'_, Self> ⓘ
source§fn map_data<F, B>(self, f: F) -> MapData<Self, F>
fn map_data<F, B>(self, f: F) -> MapData<Self, F>
1.1.0 · source§impl<T, A> BorrowMut<T> for Box<T, A>
impl<T, A> BorrowMut<T> for Box<T, A>
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Buf for Box<T>where
T: Buf + ?Sized,
impl<T> Buf for Box<T>where
T: Buf + ?Sized,
§fn remaining(&self) -> usize
fn remaining(&self) -> usize
§fn chunk(&self) -> &[u8] ⓘ
fn chunk(&self) -> &[u8] ⓘ
Buf::remaining(). Note that this can return shorter slice (this allows
non-continuous internal representation). Read more§fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize
fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize
§fn has_remaining(&self) -> bool
fn has_remaining(&self) -> bool
§fn copy_to_slice(&mut self, dst: &mut [u8])
fn copy_to_slice(&mut self, dst: &mut [u8])
§fn get_u16(&mut self) -> u16
fn get_u16(&mut self) -> u16
self in big-endian byte order. Read more§fn get_u16_le(&mut self) -> u16
fn get_u16_le(&mut self) -> u16
self in little-endian byte order. Read more§fn get_u16_ne(&mut self) -> u16
fn get_u16_ne(&mut self) -> u16
self in native-endian byte order. Read more§fn get_i16(&mut self) -> i16
fn get_i16(&mut self) -> i16
self in big-endian byte order. Read more§fn get_i16_le(&mut self) -> i16
fn get_i16_le(&mut self) -> i16
self in little-endian byte order. Read more§fn get_i16_ne(&mut self) -> i16
fn get_i16_ne(&mut self) -> i16
self in native-endian byte order. Read more§fn get_u32(&mut self) -> u32
fn get_u32(&mut self) -> u32
self in the big-endian byte order. Read more§fn get_u32_le(&mut self) -> u32
fn get_u32_le(&mut self) -> u32
self in the little-endian byte order. Read more§fn get_u32_ne(&mut self) -> u32
fn get_u32_ne(&mut self) -> u32
self in native-endian byte order. Read more§fn get_i32(&mut self) -> i32
fn get_i32(&mut self) -> i32
self in big-endian byte order. Read more§fn get_i32_le(&mut self) -> i32
fn get_i32_le(&mut self) -> i32
self in little-endian byte order. Read more§fn get_i32_ne(&mut self) -> i32
fn get_i32_ne(&mut self) -> i32
self in native-endian byte order. Read more§fn get_u64(&mut self) -> u64
fn get_u64(&mut self) -> u64
self in big-endian byte order. Read more§fn get_u64_le(&mut self) -> u64
fn get_u64_le(&mut self) -> u64
self in little-endian byte order. Read more§fn get_u64_ne(&mut self) -> u64
fn get_u64_ne(&mut self) -> u64
self in native-endian byte order. Read more§fn get_i64(&mut self) -> i64
fn get_i64(&mut self) -> i64
self in big-endian byte order. Read more§fn get_i64_le(&mut self) -> i64
fn get_i64_le(&mut self) -> i64
self in little-endian byte order. Read more§fn get_i64_ne(&mut self) -> i64
fn get_i64_ne(&mut self) -> i64
self in native-endian byte order. Read more§fn get_uint(&mut self, nbytes: usize) -> u64
fn get_uint(&mut self, nbytes: usize) -> u64
self in big-endian byte order. Read more§fn get_uint_le(&mut self, nbytes: usize) -> u64
fn get_uint_le(&mut self, nbytes: usize) -> u64
self in little-endian byte order. Read more§fn get_uint_ne(&mut self, nbytes: usize) -> u64
fn get_uint_ne(&mut self, nbytes: usize) -> u64
self in native-endian byte order. Read more§fn get_int(&mut self, nbytes: usize) -> i64
fn get_int(&mut self, nbytes: usize) -> i64
self in big-endian byte order. Read more§fn get_int_le(&mut self, nbytes: usize) -> i64
fn get_int_le(&mut self, nbytes: usize) -> i64
self in little-endian byte order. Read more§fn get_int_ne(&mut self, nbytes: usize) -> i64
fn get_int_ne(&mut self, nbytes: usize) -> i64
self in native-endian byte order. Read more§fn copy_to_bytes(&mut self, len: usize) -> Bytes
fn copy_to_bytes(&mut self, len: usize) -> Bytes
§fn get_u128(&mut self) -> u128
fn get_u128(&mut self) -> u128
self in big-endian byte order. Read more§fn get_u128_le(&mut self) -> u128
fn get_u128_le(&mut self) -> u128
self in little-endian byte order. Read more§fn get_u128_ne(&mut self) -> u128
fn get_u128_ne(&mut self) -> u128
self in native-endian byte order. Read more§fn get_i128(&mut self) -> i128
fn get_i128(&mut self) -> i128
self in big-endian byte order. Read more§fn get_i128_le(&mut self) -> i128
fn get_i128_le(&mut self) -> i128
self in little-endian byte order. Read more§fn get_i128_ne(&mut self) -> i128
fn get_i128_ne(&mut self) -> i128
self in native-endian byte order. Read more§fn get_f32(&mut self) -> f32
fn get_f32(&mut self) -> f32
self in big-endian byte order. Read more§fn get_f32_le(&mut self) -> f32
fn get_f32_le(&mut self) -> f32
self in little-endian byte order. Read more§fn get_f32_ne(&mut self) -> f32
fn get_f32_ne(&mut self) -> f32
self in native-endian byte order. Read more§fn get_f64(&mut self) -> f64
fn get_f64(&mut self) -> f64
self in big-endian byte order. Read more§fn get_f64_le(&mut self) -> f64
fn get_f64_le(&mut self) -> f64
self in little-endian byte order. Read more§fn get_f64_ne(&mut self) -> f64
fn get_f64_ne(&mut self) -> f64
self in native-endian byte order. Read more§impl<T> BufMut for Box<T>where
T: BufMut + ?Sized,
impl<T> BufMut for Box<T>where
T: BufMut + ?Sized,
§fn remaining_mut(&self) -> usize
fn remaining_mut(&self) -> usize
§fn chunk_mut(&mut self) -> &mut UninitSlice
fn chunk_mut(&mut self) -> &mut UninitSlice
BufMut::remaining_mut(). Note that this can be shorter than the
whole remainder of the buffer (this allows non-continuous implementation). Read more§unsafe fn advance_mut(&mut self, cnt: usize)
unsafe fn advance_mut(&mut self, cnt: usize)
§fn put_u16(&mut self, n: u16)
fn put_u16(&mut self, n: u16)
self in big-endian byte order. Read more§fn put_u16_le(&mut self, n: u16)
fn put_u16_le(&mut self, n: u16)
self in little-endian byte order. Read more§fn put_u16_ne(&mut self, n: u16)
fn put_u16_ne(&mut self, n: u16)
self in native-endian byte order. Read more§fn put_i16(&mut self, n: i16)
fn put_i16(&mut self, n: i16)
self in big-endian byte order. Read more§fn put_i16_le(&mut self, n: i16)
fn put_i16_le(&mut self, n: i16)
self in little-endian byte order. Read more§fn put_i16_ne(&mut self, n: i16)
fn put_i16_ne(&mut self, n: i16)
self in native-endian byte order. Read more§fn put_u32(&mut self, n: u32)
fn put_u32(&mut self, n: u32)
self in big-endian byte order. Read more§fn put_u32_le(&mut self, n: u32)
fn put_u32_le(&mut self, n: u32)
self in little-endian byte order. Read more§fn put_u32_ne(&mut self, n: u32)
fn put_u32_ne(&mut self, n: u32)
self in native-endian byte order. Read more§fn put_i32(&mut self, n: i32)
fn put_i32(&mut self, n: i32)
self in big-endian byte order. Read more§fn put_i32_le(&mut self, n: i32)
fn put_i32_le(&mut self, n: i32)
self in little-endian byte order. Read more§fn put_i32_ne(&mut self, n: i32)
fn put_i32_ne(&mut self, n: i32)
self in native-endian byte order. Read more§fn put_u64(&mut self, n: u64)
fn put_u64(&mut self, n: u64)
self in the big-endian byte order. Read more§fn put_u64_le(&mut self, n: u64)
fn put_u64_le(&mut self, n: u64)
self in little-endian byte order. Read more§fn put_u64_ne(&mut self, n: u64)
fn put_u64_ne(&mut self, n: u64)
self in native-endian byte order. Read more§fn put_i64(&mut self, n: i64)
fn put_i64(&mut self, n: i64)
self in the big-endian byte order. Read more§fn put_i64_le(&mut self, n: i64)
fn put_i64_le(&mut self, n: i64)
self in little-endian byte order. Read more§fn put_i64_ne(&mut self, n: i64)
fn put_i64_ne(&mut self, n: i64)
self in native-endian byte order. Read more§fn has_remaining_mut(&self) -> bool
fn has_remaining_mut(&self) -> bool
self for more bytes. Read more§fn put_u128(&mut self, n: u128)
fn put_u128(&mut self, n: u128)
self in the big-endian byte order. Read more§fn put_u128_le(&mut self, n: u128)
fn put_u128_le(&mut self, n: u128)
self in little-endian byte order. Read more§fn put_u128_ne(&mut self, n: u128)
fn put_u128_ne(&mut self, n: u128)
self in native-endian byte order. Read more§fn put_i128(&mut self, n: i128)
fn put_i128(&mut self, n: i128)
self in the big-endian byte order. Read more§fn put_i128_le(&mut self, n: i128)
fn put_i128_le(&mut self, n: i128)
self in little-endian byte order. Read more§fn put_i128_ne(&mut self, n: i128)
fn put_i128_ne(&mut self, n: i128)
self in native-endian byte order. Read more§fn put_uint(&mut self, n: u64, nbytes: usize)
fn put_uint(&mut self, n: u64, nbytes: usize)
self in big-endian byte order. Read more§fn put_uint_le(&mut self, n: u64, nbytes: usize)
fn put_uint_le(&mut self, n: u64, nbytes: usize)
self in the little-endian byte order. Read more§fn put_uint_ne(&mut self, n: u64, nbytes: usize)
fn put_uint_ne(&mut self, n: u64, nbytes: usize)
self in the native-endian byte order. Read more§fn put_int_le(&mut self, n: i64, nbytes: usize)
fn put_int_le(&mut self, n: i64, nbytes: usize)
§fn put_int_ne(&mut self, n: i64, nbytes: usize)
fn put_int_ne(&mut self, n: i64, nbytes: usize)
§fn put_f32(&mut self, n: f32)
fn put_f32(&mut self, n: f32)
self in big-endian byte order. Read more§fn put_f32_le(&mut self, n: f32)
fn put_f32_le(&mut self, n: f32)
self in little-endian byte order. Read more§fn put_f32_ne(&mut self, n: f32)
fn put_f32_ne(&mut self, n: f32)
self in native-endian byte order. Read more§fn put_f64(&mut self, n: f64)
fn put_f64(&mut self, n: f64)
self in big-endian byte order. Read more§fn put_f64_le(&mut self, n: f64)
fn put_f64_le(&mut self, n: f64)
self in little-endian byte order. Read more§fn put_f64_ne(&mut self, n: f64)
fn put_f64_ne(&mut self, n: f64)
self in native-endian byte order. Read more1.0.0 · source§impl<B> BufRead for Box<B>
impl<B> BufRead for Box<B>
source§fn fill_buf(&mut self) -> Result<&[u8], Error>
fn fill_buf(&mut self) -> Result<&[u8], Error>
source§fn consume(&mut self, amt: usize)
fn consume(&mut self, amt: usize)
amt bytes have been consumed from the buffer,
so they should no longer be returned in calls to read. Read moresource§fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
0xA byte) is reached, and append
them to the provided String buffer. Read moresource§fn has_data_left(&mut self) -> Result<bool, Error>
fn has_data_left(&mut self) -> Result<bool, Error>
buf_read_has_data_left)Read has any data left to be read. Read moresource§fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
bufread_skip_until)byte or EOF is reached. Read more§impl<T> BufRead for Box<T>where
T: BufRead + ?Sized,
impl<T> BufRead for Box<T>where
T: BufRead + ?Sized,
§impl<T> CalculateSizeFor for Box<T>where
T: CalculateSizeFor + ?Sized,
impl<T> CalculateSizeFor for Box<T>where
T: CalculateSizeFor + ?Sized,
§fn calculate_size_for(nr_of_el: u64) -> NonZero<u64>
fn calculate_size_for(nr_of_el: u64) -> NonZero<u64>
Self assuming the (contained) runtime-sized array has nr_of_el elements1.3.0 · source§impl<T, A> Clone for Box<[T], A>
impl<T, A> Clone for Box<[T], A>
source§fn clone_from(&mut self, source: &Box<[T], A>)
fn clone_from(&mut self, source: &Box<[T], A>)
Copies source’s contents into self without creating a new allocation,
so long as the two are of the same length.
§Examples
let x = Box::new([5, 6, 7]);
let mut y = Box::new([8, 9, 10]);
let yp: *const [i32] = &*y;
y.clone_from(&x);
// The value is the same
assert_eq!(x, y);
// And no allocation occurred
assert_eq!(yp, &*y);1.0.0 · source§impl<T, A> Clone for Box<T, A>
impl<T, A> Clone for Box<T, A>
source§fn clone(&self) -> Box<T, A>
fn clone(&self) -> Box<T, A>
Returns a new box with a clone() of this box’s contents.
§Examples
let x = Box::new(5);
let y = x.clone();
// The value is the same
assert_eq!(x, y);
// But they are unique objects
assert_ne!(&*x as *const i32, &*y as *const i32);source§fn clone_from(&mut self, source: &Box<T, A>)
fn clone_from(&mut self, source: &Box<T, A>)
Copies source’s contents into self without creating a new allocation.
§Examples
let x = Box::new(5);
let mut y = Box::new(10);
let yp: *const i32 = &*y;
y.clone_from(&x);
// The value is the same
assert_eq!(x, y);
// And no allocation occurred
assert_eq!(yp, &*y);§impl<T> Collect for Box<T>where
T: Collect + ?Sized,
impl<T> Collect for Box<T>where
T: Collect + ?Sized,
§fn trace(&self, cc: &Collection)
fn trace(&self, cc: &Collection)
Collect::trace on all held Gc pointers. If this type holds inner types that
implement Collect, a valid implementation would simply call Collect::trace on all the
held values to ensure this.§fn needs_trace() -> boolwhere
Self: Sized,
fn needs_trace() -> boolwhere
Self: Sized,
Gc pointer and trace is unnecessary
to call, you may implement this method and return false. The default implementation returns
true, signaling that Collect::trace must be called.§impl<C> Connection for Box<C>where
C: Connection + ?Sized,
impl<C> Connection for Box<C>where
C: Connection + ?Sized,
§fn wait_for_event(&self) -> Result<Event, ConnectionError>
fn wait_for_event(&self) -> Result<Event, ConnectionError>
§fn wait_for_raw_event(
&self,
) -> Result<<Box<C> as RequestConnection>::Buf, ConnectionError>
fn wait_for_raw_event( &self, ) -> Result<<Box<C> as RequestConnection>::Buf, ConnectionError>
§fn wait_for_event_with_sequence(&self) -> Result<(Event, u64), ConnectionError>
fn wait_for_event_with_sequence(&self) -> Result<(Event, u64), ConnectionError>
§fn wait_for_raw_event_with_sequence(
&self,
) -> Result<(<Box<C> as RequestConnection>::Buf, u64), ConnectionError>
fn wait_for_raw_event_with_sequence( &self, ) -> Result<(<Box<C> as RequestConnection>::Buf, u64), ConnectionError>
§fn poll_for_event(&self) -> Result<Option<Event>, ConnectionError>
fn poll_for_event(&self) -> Result<Option<Event>, ConnectionError>
§fn poll_for_raw_event(
&self,
) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
fn poll_for_raw_event( &self, ) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn poll_for_event_with_sequence(
&self,
) -> Result<Option<(Event, u64)>, ConnectionError>
fn poll_for_event_with_sequence( &self, ) -> Result<Option<(Event, u64)>, ConnectionError>
§fn poll_for_raw_event_with_sequence(
&self,
) -> Result<Option<(<Box<C> as RequestConnection>::Buf, u64)>, ConnectionError>
fn poll_for_raw_event_with_sequence( &self, ) -> Result<Option<(<Box<C> as RequestConnection>::Buf, u64)>, ConnectionError>
§fn generate_id(&self) -> Result<u32, ReplyOrIdError>
fn generate_id(&self) -> Result<u32, ReplyOrIdError>
source§impl<G, R, A> Coroutine<R> for Box<G, A>
impl<G, R, A> Coroutine<R> for Box<G, A>
§type Yield = <G as Coroutine<R>>::Yield
type Yield = <G as Coroutine<R>>::Yield
coroutine_trait)source§impl<G, R, A> Coroutine<R> for Pin<Box<G, A>>
impl<G, R, A> Coroutine<R> for Pin<Box<G, A>>
§type Yield = <G as Coroutine<R>>::Yield
type Yield = <G as Coroutine<R>>::Yield
coroutine_trait)§impl<T> CreateFrom for Box<T>where
T: CreateFrom + ?Sized,
impl<T> CreateFrom for Box<T>where
T: CreateFrom + ?Sized,
fn create_from<B>(reader: &mut Reader<B>) -> Box<T>where
B: BufferRef,
§impl<'a, T> DecodeValue<'a> for Box<T>where
T: DecodeValue<'a>,
impl<'a, T> DecodeValue<'a> for Box<T>where
T: DecodeValue<'a>,
§fn decode_value<R>(reader: &mut R, header: Header) -> Result<Box<T>, Error>where
R: Reader<'a>,
fn decode_value<R>(reader: &mut R, header: Header) -> Result<Box<T>, Error>where
R: Reader<'a>,
Reader].source§impl<'de, T> Deserialize<'de> for Box<[T]>where
T: Deserialize<'de>,
impl<'de, T> Deserialize<'de> for Box<[T]>where
T: Deserialize<'de>,
source§fn deserialize<D>(
deserializer: D,
) -> Result<Box<[T]>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<Box<[T]>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<'de> Deserialize<'de> for Box<CStr>
impl<'de> Deserialize<'de> for Box<CStr>
source§fn deserialize<D>(
deserializer: D,
) -> Result<Box<CStr>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<Box<CStr>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<'de> Deserialize<'de> for Box<OsStr>
impl<'de> Deserialize<'de> for Box<OsStr>
source§fn deserialize<D>(
deserializer: D,
) -> Result<Box<OsStr>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<Box<OsStr>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<'de> Deserialize<'de> for Box<Path>
impl<'de> Deserialize<'de> for Box<Path>
source§fn deserialize<D>(
deserializer: D,
) -> Result<Box<Path>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<Box<Path>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<'de, T> Deserialize<'de> for Box<T>where
T: Deserialize<'de>,
impl<'de, T> Deserialize<'de> for Box<T>where
T: Deserialize<'de>,
source§fn deserialize<D>(
deserializer: D,
) -> Result<Box<T>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<Box<T>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<'de> Deserialize<'de> for Box<str>
impl<'de> Deserialize<'de> for Box<str>
source§fn deserialize<D>(
deserializer: D,
) -> Result<Box<str>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<Box<str>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl<'de, T> Deserializer<'de> for Box<T>where
T: Deserializer<'de> + ?Sized,
impl<'de, T> Deserializer<'de> for Box<T>where
T: Deserializer<'de> + ?Sized,
fn erased_deserialize_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bool( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_char( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_str( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_string( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bytes( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_byte_buf( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_option( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_newtype_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_seq( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple( &mut self, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple_struct( &mut self, name: &'static str, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_map( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_struct( &mut self, name: &'static str, fields: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_identifier( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_enum( &mut self, name: &'static str, variants: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_ignored_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_is_human_readable(&self) -> bool
source§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + '_>
fn erased_deserialize_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bool( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_char( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_str( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_string( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bytes( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_byte_buf( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_option( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_newtype_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_seq( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple( &mut self, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple_struct( &mut self, name: &'static str, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_map( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_struct( &mut self, name: &'static str, fields: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_identifier( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_enum( &mut self, name: &'static str, variants: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_ignored_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_is_human_readable(&self) -> bool
source§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + '_>
source§fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserializer to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a bool value.source§fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i8 value.source§fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i16 value.source§fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i32 value.source§fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i64 value.source§fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u8 value.source§fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u16 value.source§fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u32 value.source§fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u64 value.source§fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f32 value.source§fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f64 value.source§fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a char value.source§fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit struct with a
particular name.source§fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a newtype struct with a
particular name.source§fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a tuple struct with a
particular name and number of fields.source§fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a struct with a particular
name and fields.source§fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting the name of a struct
field or the discriminant of an enum variant.source§fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an enum value with a
particular name and possible variants.source§fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Deserialize implementations should expect to
deserialize their human-readable form. Read moresource§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + '_>
source§fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserializer to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a bool value.source§fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i8 value.source§fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i16 value.source§fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i32 value.source§fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i64 value.source§fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u8 value.source§fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u16 value.source§fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u32 value.source§fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u64 value.source§fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f32 value.source§fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f64 value.source§fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a char value.source§fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit struct with a
particular name.source§fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a newtype struct with a
particular name.source§fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a tuple struct with a
particular name and number of fields.source§fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a struct with a particular
name and fields.source§fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting the name of a struct
field or the discriminant of an enum variant.source§fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an enum value with a
particular name and possible variants.source§fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Deserialize implementations should expect to
deserialize their human-readable form. Read moresource§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + '_>
fn erased_deserialize_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bool( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_char( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_str( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_string( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bytes( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_byte_buf( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_option( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_newtype_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_seq( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple( &mut self, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple_struct( &mut self, name: &'static str, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_map( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_struct( &mut self, name: &'static str, fields: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_identifier( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_enum( &mut self, name: &'static str, variants: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_ignored_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_is_human_readable(&self) -> bool
source§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + '_>
source§fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserializer to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a bool value.source§fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i8 value.source§fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i16 value.source§fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i32 value.source§fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i64 value.source§fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u8 value.source§fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u16 value.source§fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u32 value.source§fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u64 value.source§fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f32 value.source§fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f64 value.source§fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a char value.source§fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit struct with a
particular name.source§fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a newtype struct with a
particular name.source§fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a tuple struct with a
particular name and number of fields.source§fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a struct with a particular
name and fields.source§fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting the name of a struct
field or the discriminant of an enum variant.source§fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an enum value with a
particular name and possible variants.source§fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Deserialize implementations should expect to
deserialize their human-readable form. Read moresource§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + '_>
source§fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserializer to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a bool value.source§fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i8 value.source§fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i16 value.source§fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i32 value.source§fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i64 value.source§fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u8 value.source§fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u16 value.source§fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u32 value.source§fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u64 value.source§fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f32 value.source§fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f64 value.source§fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a char value.source§fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit struct with a
particular name.source§fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a newtype struct with a
particular name.source§fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a tuple struct with a
particular name and number of fields.source§fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a struct with a particular
name and fields.source§fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting the name of a struct
field or the discriminant of an enum variant.source§fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an enum value with a
particular name and possible variants.source§fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Deserialize implementations should expect to
deserialize their human-readable form. Read moresource§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + Sync + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + Sync + '_>
fn erased_deserialize_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bool( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_char( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_str( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_string( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bytes( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_byte_buf( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_option( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_newtype_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_seq( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple( &mut self, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple_struct( &mut self, name: &'static str, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_map( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_struct( &mut self, name: &'static str, fields: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_identifier( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_enum( &mut self, name: &'static str, variants: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_ignored_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_is_human_readable(&self) -> bool
source§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + Sync + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + Sync + '_>
source§fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserializer to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a bool value.source§fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i8 value.source§fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i16 value.source§fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i32 value.source§fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i64 value.source§fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u8 value.source§fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u16 value.source§fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u32 value.source§fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u64 value.source§fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f32 value.source§fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f64 value.source§fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a char value.source§fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit struct with a
particular name.source§fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a newtype struct with a
particular name.source§fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a tuple struct with a
particular name and number of fields.source§fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a struct with a particular
name and fields.source§fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting the name of a struct
field or the discriminant of an enum variant.source§fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an enum value with a
particular name and possible variants.source§fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Deserialize implementations should expect to
deserialize their human-readable form. Read moresource§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + Sync + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Send + Sync + '_>
source§fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserializer to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a bool value.source§fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i8 value.source§fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i16 value.source§fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i32 value.source§fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i64 value.source§fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u8 value.source§fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u16 value.source§fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u32 value.source§fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u64 value.source§fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f32 value.source§fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f64 value.source§fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a char value.source§fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit struct with a
particular name.source§fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a newtype struct with a
particular name.source§fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a tuple struct with a
particular name and number of fields.source§fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a struct with a particular
name and fields.source§fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting the name of a struct
field or the discriminant of an enum variant.source§fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an enum value with a
particular name and possible variants.source§fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Deserialize implementations should expect to
deserialize their human-readable form. Read moresource§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Sync + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Sync + '_>
fn erased_deserialize_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bool( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_i128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u8( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u16( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_u128( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f32( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_f64( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_char( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_str( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_string( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_bytes( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_byte_buf( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_option( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_unit_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_newtype_struct( &mut self, name: &'static str, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_seq( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple( &mut self, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_tuple_struct( &mut self, name: &'static str, len: usize, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_map( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_struct( &mut self, name: &'static str, fields: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_identifier( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_enum( &mut self, name: &'static str, variants: &'static [&'static str], visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_deserialize_ignored_any( &mut self, visitor: &mut dyn Visitor<'de>, ) -> Result<Out, Error>
fn erased_is_human_readable(&self) -> bool
source§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Sync + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Sync + '_>
source§fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserializer to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a bool value.source§fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i8 value.source§fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i16 value.source§fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i32 value.source§fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i64 value.source§fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u8 value.source§fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u16 value.source§fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u32 value.source§fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u64 value.source§fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f32 value.source§fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f64 value.source§fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a char value.source§fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit struct with a
particular name.source§fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a newtype struct with a
particular name.source§fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a tuple struct with a
particular name and number of fields.source§fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a struct with a particular
name and fields.source§fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting the name of a struct
field or the discriminant of an enum variant.source§fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an enum value with a
particular name and possible variants.source§fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Deserialize implementations should expect to
deserialize their human-readable form. Read moresource§impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Sync + '_>
impl<'de> Deserializer<'de> for Box<dyn Deserializer<'de> + Sync + '_>
source§fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserializer to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bool<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a bool value.source§fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i8 value.source§fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i16 value.source§fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i32 value.source§fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an i64 value.source§fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_i128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u8<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u8 value.source§fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u16<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u16 value.source§fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u32 value.source§fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a u64 value.source§fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_u128<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
source§fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f32<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f32 value.source§fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_f64<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a f64 value.source§fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_char<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a char value.source§fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_str<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_string<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_bytes<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_byte_buf<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer. Read moresource§fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_option<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_unit_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a unit struct with a
particular name.source§fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_newtype_struct<V>(
self,
name: &'static str,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a newtype struct with a
particular name.source§fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_seq<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple<V>(
self,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_tuple_struct<V>(
self,
name: &'static str,
len: usize,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a tuple struct with a
particular name and number of fields.source§fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_map<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_struct<V>(
self,
name: &'static str,
fields: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting a struct with a particular
name and fields.source§fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_identifier<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting the name of a struct
field or the discriminant of an enum variant.source§fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_enum<V>(
self,
name: &'static str,
variants: &'static [&'static str],
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type is expecting an enum value with a
particular name and possible variants.source§fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
fn deserialize_ignored_any<V>(
self,
visitor: V,
) -> Result<<V as Visitor<'de>>::Value, Error>where
V: Visitor<'de>,
Deserialize type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Deserialize implementations should expect to
deserialize their human-readable form. Read moresource§impl<I> DoubleEndedFallibleIterator for Box<I>where
I: DoubleEndedFallibleIterator + ?Sized,
impl<I> DoubleEndedFallibleIterator for Box<I>where
I: DoubleEndedFallibleIterator + ?Sized,
source§fn next_back(
&mut self,
) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
fn next_back( &mut self, ) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
1.0.0 · source§impl<I, A> DoubleEndedIterator for Box<I, A>
impl<I, A> DoubleEndedIterator for Box<I, A>
source§fn next_back(&mut self) -> Option<<I as Iterator>::Item>
fn next_back(&mut self) -> Option<<I as Iterator>::Item>
source§fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>
fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>
nth element from the end of the iterator. Read moresource§fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by)n elements. Read more1.27.0 · source§fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
Iterator::try_fold(): it takes
elements starting from the back of the iterator. Read moresource§impl Error for Box<ErrorKind>
impl Error for Box<ErrorKind>
source§fn custom<T>(desc: T) -> Box<ErrorKind>where
T: Display,
fn custom<T>(desc: T) -> Box<ErrorKind>where
T: Display,
source§fn invalid_type(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self
fn invalid_type(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self
Deserialize receives a type different from what it was
expecting. Read moresource§fn invalid_value(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self
fn invalid_value(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self
Deserialize receives a value of the right type but that
is wrong for some other reason. Read moresource§fn invalid_length(len: usize, exp: &dyn Expected) -> Self
fn invalid_length(len: usize, exp: &dyn Expected) -> Self
source§fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self
fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self
Deserialize enum type received a variant with an
unrecognized name.source§fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self
fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self
Deserialize struct type received a field with an
unrecognized name.source§fn missing_field(field: &'static str) -> Self
fn missing_field(field: &'static str) -> Self
Deserialize struct type expected to receive a required
field with a particular name but that field was not present in the
input.source§fn duplicate_field(field: &'static str) -> Self
fn duplicate_field(field: &'static str) -> Self
Deserialize struct type received more than one of the
same field.1.8.0 · source§impl<T> Error for Box<T>where
T: Error,
impl<T> Error for Box<T>where
T: Error,
source§fn description(&self) -> &str
fn description(&self) -> &str
source§fn cause(&self) -> Option<&dyn Error>
fn cause(&self) -> Option<&dyn Error>
1.0.0 · source§impl<I, A> ExactSizeIterator for Box<I, A>
impl<I, A> ExactSizeIterator for Box<I, A>
1.45.0 · source§impl<A> Extend<Box<str, A>> for Stringwhere
A: Allocator,
impl<A> Extend<Box<str, A>> for Stringwhere
A: Allocator,
source§fn extend<I>(&mut self, iter: I)
fn extend<I>(&mut self, iter: I)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one)source§impl<I> FallibleIterator for Box<I>where
I: FallibleIterator + ?Sized,
impl<I> FallibleIterator for Box<I>where
I: FallibleIterator + ?Sized,
§type Item = <I as FallibleIterator>::Item
type Item = <I as FallibleIterator>::Item
§type Error = <I as FallibleIterator>::Error
type Error = <I as FallibleIterator>::Error
source§fn next(
&mut self,
) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
fn next( &mut self, ) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
source§fn nth(
&mut self,
n: usize,
) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
fn nth( &mut self, n: usize, ) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
nth element of the iterator.source§fn count(self) -> Result<usize, Self::Error>where
Self: Sized,
fn count(self) -> Result<usize, Self::Error>where
Self: Sized,
source§fn last(self) -> Result<Option<Self::Item>, Self::Error>where
Self: Sized,
fn last(self) -> Result<Option<Self::Item>, Self::Error>where
Self: Sized,
source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
source§fn chain<I>(self, it: I) -> Chain<Self, I>
fn chain<I>(self, it: I) -> Chain<Self, I>
source§fn zip<I>(
self,
o: I,
) -> Zip<Self, <I as IntoFallibleIterator>::IntoFallibleIter>
fn zip<I>( self, o: I, ) -> Zip<Self, <I as IntoFallibleIterator>::IntoFallibleIter>
source§fn map<F, B>(self, f: F) -> Map<Self, F>
fn map<F, B>(self, f: F) -> Map<Self, F>
source§fn for_each<F>(self, f: F) -> Result<(), Self::Error>
fn for_each<F>(self, f: F) -> Result<(), Self::Error>
source§fn filter<F>(self, f: F) -> Filter<Self, F>
fn filter<F>(self, f: F) -> Filter<Self, F>
source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
source§fn peekable(self) -> Peekable<Self>where
Self: Sized,
fn peekable(self) -> Peekable<Self>where
Self: Sized,
source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n values of this iterator.source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n values of this
iterator.source§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn fuse(self) -> Fuse<Self>where
Self: Sized,
fn fuse(self) -> Fuse<Self>where
Self: Sized,
Ok(None). Read moresource§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect<T>(self) -> Result<T, Self::Error>
fn collect<T>(self) -> Result<T, Self::Error>
source§fn partition<B, F>(self, f: F) -> Result<(B, B), Self::Error>
fn partition<B, F>(self, f: F) -> Result<(B, B), Self::Error>
source§fn fold<B, F>(self, init: B, f: F) -> Result<B, Self::Error>
fn fold<B, F>(self, init: B, f: F) -> Result<B, Self::Error>
source§fn try_fold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E>
fn try_fold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E>
source§fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>
fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>
source§fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>
fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>
source§fn find<F>(&mut self, f: F) -> Result<Option<Self::Item>, Self::Error>
fn find<F>(&mut self, f: F) -> Result<Option<Self::Item>, Self::Error>
source§fn find_map<B, F>(&mut self, f: F) -> Result<Option<B>, Self::Error>
fn find_map<B, F>(&mut self, f: F) -> Result<Option<B>, Self::Error>
None result.source§fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>
fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>
source§fn max_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
fn max_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
source§fn max_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
fn max_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
source§fn min_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
fn min_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
source§fn min_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
fn min_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>
source§fn unzip<A, B, FromA, FromB>(self) -> Result<(FromA, FromB), Self::Error>
fn unzip<A, B, FromA, FromB>(self) -> Result<(FromA, FromB), Self::Error>
source§fn partial_cmp<I>(self, other: I) -> Result<Option<Ordering>, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
fn partial_cmp<I>(self, other: I) -> Result<Option<Ordering>, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
source§fn eq<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,
fn eq<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,
source§fn ne<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,
fn ne<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,
source§fn lt<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
fn lt<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
source§fn le<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
fn le<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
source§fn gt<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
fn gt<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
source§fn ge<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
fn ge<I>(self, other: I) -> Result<bool, Self::Error>where
Self: Sized,
I: IntoFallibleIterator<Error = Self::Error>,
Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
§impl<S> Filter<S> for Box<dyn Filter<S> + Send + Sync>
impl<S> Filter<S> for Box<dyn Filter<S> + Send + Sync>
§fn enabled(&self, meta: &Metadata<'_>, cx: &Context<'_, S>) -> bool
fn enabled(&self, meta: &Metadata<'_>, cx: &Context<'_, S>) -> bool
true if this layer is interested in a span or event with the
given Metadata in the current [Context], similarly to
Subscriber::enabled. Read more§fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest
fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest
§fn max_level_hint(&self) -> Option<LevelFilter>
fn max_level_hint(&self) -> Option<LevelFilter>
§fn event_enabled(&self, event: &Event<'_>, cx: &Context<'_, S>) -> bool
fn event_enabled(&self, event: &Event<'_>, cx: &Context<'_, S>) -> bool
Layer]'s [on_event], to determine if on_event` should be called. Read more§fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)
fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)
§fn on_enter(&self, id: &Id, ctx: Context<'_, S>)
fn on_enter(&self, id: &Id, ctx: Context<'_, S>)
1.17.0 · source§impl<T> From<&[T]> for Box<[T]>where
T: Clone,
impl<T> From<&[T]> for Box<[T]>where
T: Clone,
source§fn from(slice: &[T]) -> Box<[T]>
fn from(slice: &[T]) -> Box<[T]>
Converts a &[T] into a Box<[T]>
This conversion allocates on the heap
and performs a copy of slice and its contents.
§Examples
// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice: Box<[u8]> = Box::from(slice);
println!("{boxed_slice:?}");1.6.0 · source§impl<'a> From<&str> for Box<dyn Error + 'a>
impl<'a> From<&str> for Box<dyn Error + 'a>
1.0.0 · source§impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>
impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>
1.33.0 · source§impl<T, A> From<Box<T, A>> for Pin<Box<T, A>>
impl<T, A> From<Box<T, A>> for Pin<Box<T, A>>
source§fn from(boxed: Box<T, A>) -> Pin<Box<T, A>>
fn from(boxed: Box<T, A>) -> Pin<Box<T, A>>
Converts a Box<T> into a Pin<Box<T>>. If T does not implement Unpin, then
*boxed will be pinned in memory and unable to be moved.
This conversion does not allocate on the heap and happens in place.
This is also available via Box::into_pin.
Constructing and pinning a Box with <Pin<Box<T>>>::from(Box::new(x))
can also be written more concisely using Box::pin(x).
This From implementation is useful if you already have a Box<T>, or you are
constructing a (pinned) Box in a different way than with Box::new.
1.19.0 · source§impl<A> From<Box<str, A>> for Box<[u8], A>where
A: Allocator,
impl<A> From<Box<str, A>> for Box<[u8], A>where
A: Allocator,
source§fn from(s: Box<str, A>) -> Box<[u8], A>
fn from(s: Box<str, A>) -> Box<[u8], A>
Converts a Box<str> into a Box<[u8]>
This conversion does not allocate on the heap and happens in place.
§Examples
// create a Box<str> which will be used to create a Box<[u8]>
let boxed: Box<str> = Box::from("hello");
let boxed_str: Box<[u8]> = Box::from(boxed);
// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice = Box::from(slice);
assert_eq!(boxed_slice, boxed_str);1.45.0 · source§impl From<Cow<'_, str>> for Box<str>
impl From<Cow<'_, str>> for Box<str>
source§fn from(cow: Cow<'_, str>) -> Box<str>
fn from(cow: Cow<'_, str>) -> Box<str>
Converts a Cow<'_, str> into a Box<str>
When cow is the Cow::Borrowed variant, this
conversion allocates on the heap and copies the
underlying str. Otherwise, it will try to reuse the owned
String’s allocation.
§Examples
use std::borrow::Cow;
let unboxed = Cow::Borrowed("hello");
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");let unboxed = Cow::Owned("hello".to_string());
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");1.22.0 · source§impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>
impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>
1.22.0 · source§impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>
impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>
source§fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>
fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>
Converts a Cow into a box of dyn Error + Send + Sync.
§Examples
use std::error::Error;
use std::mem;
use std::borrow::Cow;
let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))1.0.0 · source§impl<'a, E> From<E> for Box<dyn Error + 'a>where
E: Error + 'a,
impl<'a, E> From<E> for Box<dyn Error + 'a>where
E: Error + 'a,
source§fn from(err: E) -> Box<dyn Error + 'a>
fn from(err: E) -> Box<dyn Error + 'a>
Converts a type of Error into a box of dyn Error.
§Examples
use std::error::Error;
use std::fmt;
use std::mem;
#[derive(Debug)]
struct AnError;
impl fmt::Display for AnError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "An error")
}
}
impl Error for AnError {}
let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error>::from(an_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))1.0.0 · source§impl<'a, E> From<E> for Box<dyn Error + Send + Sync + 'a>
impl<'a, E> From<E> for Box<dyn Error + Send + Sync + 'a>
source§fn from(err: E) -> Box<dyn Error + Send + Sync + 'a>
fn from(err: E) -> Box<dyn Error + Send + Sync + 'a>
Converts a type of Error + Send + Sync into a box of
dyn Error + Send + Sync.
§Examples
use std::error::Error;
use std::fmt;
use std::mem;
#[derive(Debug)]
struct AnError;
impl fmt::Display for AnError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "An error")
}
}
impl Error for AnError {}
unsafe impl Send for AnError {}
unsafe impl Sync for AnError {}
let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))1.6.0 · source§impl<'a> From<String> for Box<dyn Error + 'a>
impl<'a> From<String> for Box<dyn Error + 'a>
1.0.0 · source§impl<'a> From<String> for Box<dyn Error + Send + Sync + 'a>
impl<'a> From<String> for Box<dyn Error + Send + Sync + 'a>
source§fn from(err: String) -> Box<dyn Error + Send + Sync + 'a>
fn from(err: String) -> Box<dyn Error + Send + Sync + 'a>
Converts a String into a box of dyn Error + Send + Sync.
§Examples
use std::error::Error;
use std::mem;
let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))1.20.0 · source§impl<T, A> From<Vec<T, A>> for Box<[T], A>where
A: Allocator,
impl<T, A> From<Vec<T, A>> for Box<[T], A>where
A: Allocator,
source§fn from(v: Vec<T, A>) -> Box<[T], A>
fn from(v: Vec<T, A>) -> Box<[T], A>
Convert a vector into a boxed slice.
Before doing the conversion, this method discards excess capacity like Vec::shrink_to_fit.
§Examples
assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());Any excess capacity is removed:
let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3]);
assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());1.32.0 · source§impl<I> FromIterator<I> for Box<[I]>
impl<I> FromIterator<I> for Box<[I]>
§impl<F> FusedFuture for Box<F>
impl<F> FusedFuture for Box<F>
§fn is_terminated(&self) -> bool
fn is_terminated(&self) -> bool
true if the underlying future should no longer be polled.§impl<S> FusedStream for Box<S>
impl<S> FusedStream for Box<S>
§fn is_terminated(&self) -> bool
fn is_terminated(&self) -> bool
true if the stream should no longer be polled.§impl<T> GenCore for Box<T>
impl<T> GenCore for Box<T>
§const GEN_KIND: TurboKind = T::GEN_KIND
const GEN_KIND: TurboKind = T::GEN_KIND
TurboKind::FAST RNGs are meant to be very
quick, non-cryptographic PRNGs, while TurboKind::SLOW are slower,
more expensive PRNGs, usually CSPRNGs but not always. Setting this constant
allows for certain algorithms to be toggled for tuning performance of certain
methods.1.22.0 · source§impl<T, A> Hasher for Box<T, A>
impl<T, A> Hasher for Box<T, A>
source§fn write_u128(&mut self, i: u128)
fn write_u128(&mut self, i: u128)
u128 into this hasher.source§fn write_usize(&mut self, i: usize)
fn write_usize(&mut self, i: usize)
usize into this hasher.source§fn write_i128(&mut self, i: i128)
fn write_i128(&mut self, i: i128)
i128 into this hasher.source§fn write_isize(&mut self, i: isize)
fn write_isize(&mut self, i: isize)
isize into this hasher.source§fn write_length_prefix(&mut self, len: usize)
fn write_length_prefix(&mut self, len: usize)
hasher_prefixfree_extras)§impl<T> ImageDecoder for Box<T>where
T: ImageDecoder + ?Sized,
impl<T> ImageDecoder for Box<T>where
T: ImageDecoder + ?Sized,
§fn dimensions(&self) -> (u32, u32)
fn dimensions(&self) -> (u32, u32)
§fn color_type(&self) -> ColorType
fn color_type(&self) -> ColorType
§fn original_color_type(&self) -> ExtendedColorType
fn original_color_type(&self) -> ExtendedColorType
§fn icc_profile(&mut self) -> Result<Option<Vec<u8>>, ImageError>
fn icc_profile(&mut self) -> Result<Option<Vec<u8>>, ImageError>
Ok(None) if the image does not have one. Read more§fn total_bytes(&self) -> u64
fn total_bytes(&self) -> u64
§fn read_image(self, buf: &mut [u8]) -> Result<(), ImageError>
fn read_image(self, buf: &mut [u8]) -> Result<(), ImageError>
§impl<K, V> IntoIterator for Box<Slice<K, V>>
impl<K, V> IntoIterator for Box<Slice<K, V>>
§impl<T> IntoIterator for Box<Slice<T>>
impl<T> IntoIterator for Box<Slice<T>>
§impl IntoSystemConfigs<()> for Box<dyn System<In = (), Out = ()>>
impl IntoSystemConfigs<()> for Box<dyn System<In = (), Out = ()>>
§fn distributive_run_if<M>(
self,
condition: impl Condition<M> + Clone,
) -> SystemConfigs
fn distributive_run_if<M>( self, condition: impl Condition<M> + Clone, ) -> SystemConfigs
§fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs
fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs
set.§fn ambiguous_with_all(self) -> SystemConfigs
fn ambiguous_with_all(self) -> SystemConfigs
§fn on_startup(self) -> SystemConfigs
fn on_startup(self) -> SystemConfigs
app.add_system(foo.on_startup()) has been deprecated in favor of app.add_systems(Startup, foo). Please migrate to that API.CoreSchedule::Startup.
This was a shorthand for self.in_schedule(CoreSchedule::Startup). Read more§fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemConfigs
fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemConfigs
app.add_system(foo.in_schedule(SomeSchedule)) has been deprecated in favor of app.add_systems(SomeSchedule, foo). Please migrate to that API.schedule. Read more§impl IntoSystemSetConfig for Box<dyn SystemSet>
impl IntoSystemSetConfig for Box<dyn SystemSet>
§fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfig
fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemSetConfig
set.§fn ambiguous_with_all(self) -> SystemSetConfig
fn ambiguous_with_all(self) -> SystemSetConfig
§fn on_startup(self) -> SystemSetConfigs
fn on_startup(self) -> SystemSetConfigs
app.configure_set(MySet.on_startup()) has been deprecated in favor of app.configure_set(Startup, MySet). Please migrate to that API.CoreSchedule::Startup schedule.
This was a shorthand for self.in_schedule(CoreSchedule::Startup). Read more§fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemSetConfigs
fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemSetConfigs
app.configure_set(MySet.in_schedule(SomeSchedule)) has been deprecated in favor of app.configure_set(SomeSchedule, MySet). Please migrate to that API.schedule. Read more1.80.0 · source§impl<'a, I, A> !Iterator for &'a Box<[I], A>where
A: Allocator,
impl<'a, I, A> !Iterator for &'a Box<[I], A>where
A: Allocator,
This implementation is required to make sure that the &Box<[I]>: IntoIterator
implementation doesn’t overlap with IntoIterator for T where T: Iterator blanket.
1.0.0 · source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
source§fn next_chunk<const N: usize>(
&mut self,
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self,
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk)N values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where
Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by)n elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
nth element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows)f for each contiguous window of size N over
self and returns an iterator over the outputs of f. Like slice::windows(),
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned)true precede all those that return false. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> B
fn fold<B, F>(self, init: B, f: F) -> B
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<R>(
&mut self,
f: impl FnMut(Self::Item, Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<R>(
&mut self,
f: impl FnMut(&Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks)N elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd elements of
this Iterator with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted)1.80.0 · source§impl<'a, I, A> !Iterator for &'a mut Box<[I], A>where
A: Allocator,
impl<'a, I, A> !Iterator for &'a mut Box<[I], A>where
A: Allocator,
This implementation is required to make sure that the &mut Box<[I]>: IntoIterator
implementation doesn’t overlap with IntoIterator for T where T: Iterator blanket.
1.0.0 · source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
source§fn next_chunk<const N: usize>(
&mut self,
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self,
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk)N values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where
Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by)n elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
nth element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows)f for each contiguous window of size N over
self and returns an iterator over the outputs of f. Like slice::windows(),
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned)true precede all those that return false. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> B
fn fold<B, F>(self, init: B, f: F) -> B
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<R>(
&mut self,
f: impl FnMut(Self::Item, Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<R>(
&mut self,
f: impl FnMut(&Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks)N elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd elements of
this Iterator with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted)1.80.0 · source§impl<I, A> !Iterator for Box<[I], A>where
A: Allocator,
impl<I, A> !Iterator for Box<[I], A>where
A: Allocator,
This implementation is required to make sure that the Box<[I]>: IntoIterator
implementation doesn’t overlap with IntoIterator for T where T: Iterator blanket.
1.0.0 · source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
source§fn next_chunk<const N: usize>(
&mut self,
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self,
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk)N values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where
Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by)n elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
nth element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows)f for each contiguous window of size N over
self and returns an iterator over the outputs of f. Like slice::windows(),
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned)true precede all those that return false. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> B
fn fold<B, F>(self, init: B, f: F) -> B
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<R>(
&mut self,
f: impl FnMut(Self::Item, Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<R>(
&mut self,
f: impl FnMut(&Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks)N elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd elements of
this Iterator with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted)1.0.0 · source§impl<I, A> Iterator for Box<I, A>
impl<I, A> Iterator for Box<I, A>
source§fn next(&mut self) -> Option<<I as Iterator>::Item>
fn next(&mut self) -> Option<<I as Iterator>::Item>
source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
source§fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
nth element of the iterator. Read moresource§fn last(self) -> Option<<I as Iterator>::Item>
fn last(self) -> Option<<I as Iterator>::Item>
source§fn next_chunk<const N: usize>(
&mut self,
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self,
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk)N values. Read more1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by)n elements. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows)f for each contiguous window of size N over
self and returns an iterator over the outputs of f. Like slice::windows(),
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned)true precede all those that return false. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> B
fn fold<B, F>(self, init: B, f: F) -> B
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<R>(
&mut self,
f: impl FnMut(Self::Item, Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<R>(
&mut self,
f: impl FnMut(&Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>
fn copied<'a, T>(self) -> Copied<Self>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks)N elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd elements of
this Iterator with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by)Iterator with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted)§impl<L, S> Layer<S> for Box<L>where
L: Layer<S>,
S: Subscriber,
impl<L, S> Layer<S> for Box<L>where
L: Layer<S>,
S: Subscriber,
§fn on_register_dispatch(&self, subscriber: &Dispatch)
fn on_register_dispatch(&self, subscriber: &Dispatch)
Subscriber. Read more§fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)
fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)
Attributes and Id.§fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
Subscriber::register_callsite. Read more§fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool
fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool
true if this layer is interested in a span or event with the
given metadata in the current [Context], similarly to
Subscriber::enabled. Read more§fn on_record(&self, span: &Id, values: &Record<'_>, ctx: Context<'_, S>)
fn on_record(&self, span: &Id, values: &Record<'_>, ctx: Context<'_, S>)
Id recorded the given
values.§fn on_follows_from(&self, span: &Id, follows: &Id, ctx: Context<'_, S>)
fn on_follows_from(&self, span: &Id, follows: &Id, ctx: Context<'_, S>)
span recorded that it
follows from the span with the ID follows.§fn event_enabled(&self, event: &Event<'_>, ctx: Context<'_, S>) -> bool
fn event_enabled(&self, event: &Event<'_>, ctx: Context<'_, S>) -> bool
§fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>)
fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>)
§fn on_enter(&self, id: &Id, ctx: Context<'_, S>)
fn on_enter(&self, id: &Id, ctx: Context<'_, S>)
§fn on_exit(&self, id: &Id, ctx: Context<'_, S>)
fn on_exit(&self, id: &Id, ctx: Context<'_, S>)
§fn on_close(&self, id: Id, ctx: Context<'_, S>)
fn on_close(&self, id: Id, ctx: Context<'_, S>)
§fn on_id_change(&self, old: &Id, new: &Id, ctx: Context<'_, S>)
fn on_id_change(&self, old: &Id, new: &Id, ctx: Context<'_, S>)
§fn and_then<L>(self, layer: L) -> Layered<L, Self, S>where
L: Layer<S>,
Self: Sized,
fn and_then<L>(self, layer: L) -> Layered<L, Self, S>where
L: Layer<S>,
Self: Sized,
Layer, returning a Layered
struct implementing Layer. Read more§fn with_subscriber(self, inner: S) -> Layered<Self, S>where
Self: Sized,
fn with_subscriber(self, inner: S) -> Layered<Self, S>where
Self: Sized,
Layer with the given Subscriber, returning a
Layered struct that implements Subscriber. Read more§fn with_filter<F>(self, filter: F) -> Filtered<Self, F, S>where
Self: Sized,
F: Filter<S>,
fn with_filter<F>(self, filter: F) -> Filtered<Self, F, S>where
Self: Sized,
F: Filter<S>,
§impl<S> Layer<S> for Box<dyn Layer<S> + Send + Sync>where
S: Subscriber,
impl<S> Layer<S> for Box<dyn Layer<S> + Send + Sync>where
S: Subscriber,
§fn on_register_dispatch(&self, subscriber: &Dispatch)
fn on_register_dispatch(&self, subscriber: &Dispatch)
Subscriber. Read more§fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)
fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)
Attributes and Id.§fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
Subscriber::register_callsite. Read more§fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool
fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool
true if this layer is interested in a span or event with the
given metadata in the current [Context], similarly to
Subscriber::enabled. Read more§fn on_record(&self, span: &Id, values: &Record<'_>, ctx: Context<'_, S>)
fn on_record(&self, span: &Id, values: &Record<'_>, ctx: Context<'_, S>)
Id recorded the given
values.§fn on_follows_from(&self, span: &Id, follows: &Id, ctx: Context<'_, S>)
fn on_follows_from(&self, span: &Id, follows: &Id, ctx: Context<'_, S>)
span recorded that it
follows from the span with the ID follows.§fn event_enabled(&self, event: &Event<'_>, ctx: Context<'_, S>) -> bool
fn event_enabled(&self, event: &Event<'_>, ctx: Context<'_, S>) -> bool
§fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>)
fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>)
§fn on_enter(&self, id: &Id, ctx: Context<'_, S>)
fn on_enter(&self, id: &Id, ctx: Context<'_, S>)
§fn on_exit(&self, id: &Id, ctx: Context<'_, S>)
fn on_exit(&self, id: &Id, ctx: Context<'_, S>)
§fn on_close(&self, id: Id, ctx: Context<'_, S>)
fn on_close(&self, id: Id, ctx: Context<'_, S>)
§fn on_id_change(&self, old: &Id, new: &Id, ctx: Context<'_, S>)
fn on_id_change(&self, old: &Id, new: &Id, ctx: Context<'_, S>)
§fn and_then<L>(self, layer: L) -> Layered<L, Self, S>where
L: Layer<S>,
Self: Sized,
fn and_then<L>(self, layer: L) -> Layered<L, Self, S>where
L: Layer<S>,
Self: Sized,
Layer, returning a Layered
struct implementing Layer. Read more§fn with_subscriber(self, inner: S) -> Layered<Self, S>where
Self: Sized,
fn with_subscriber(self, inner: S) -> Layered<Self, S>where
Self: Sized,
Layer with the given Subscriber, returning a
Layered struct that implements Subscriber. Read more§fn with_filter<F>(self, filter: F) -> Filtered<Self, F, S>where
Self: Sized,
F: Filter<S>,
fn with_filter<F>(self, filter: F) -> Filtered<Self, F, S>where
Self: Sized,
F: Filter<S>,
1.0.0 · source§impl<T, A> Ord for Box<T, A>
impl<T, A> Ord for Box<T, A>
§impl<'a, I, O, E> Parser<I, O, E> for Box<dyn Parser<I, O, E> + 'a>
impl<'a, I, O, E> Parser<I, O, E> for Box<dyn Parser<I, O, E> + 'a>
§fn parse(&mut self, input: I) -> Result<(I, O), Err<E>>
fn parse(&mut self, input: I) -> Result<(I, O), Err<E>>
Result containing
either the remaining input and the output value, or an error§fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O>
fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O>
§fn and_then<G, O2>(self, g: G) -> AndThen<Self, G, O>where
G: Parser<O, O2, E>,
Self: Sized,
fn and_then<G, O2>(self, g: G) -> AndThen<Self, G, O>where
G: Parser<O, O2, E>,
Self: Sized,
§fn and<G, O2>(self, g: G) -> And<Self, G>where
G: Parser<I, O2, E>,
Self: Sized,
fn and<G, O2>(self, g: G) -> And<Self, G>where
G: Parser<I, O2, E>,
Self: Sized,
1.0.0 · source§impl<T, A> PartialEq for Box<T, A>
impl<T, A> PartialEq for Box<T, A>
1.0.0 · source§impl<T, A> PartialOrd for Box<T, A>
impl<T, A> PartialOrd for Box<T, A>
source§fn le(&self, other: &Box<T, A>) -> bool
fn le(&self, other: &Box<T, A>) -> bool
self and other) and is used by the <=
operator. Read more1.0.0 · source§impl<R> Read for Box<R>
impl<R> Read for Box<R>
source§fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
source§fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
read_buf)source§fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
read, except that it reads into a slice of buffers. Read moresource§fn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
can_vector)source§fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
buf. Read moresource§fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
buf. Read moresource§fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
buf. Read moresource§fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
read_buf)cursor. Read more1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
Read. Read more§impl<T> Read for Box<T>where
T: Read + ?Sized,
impl<T> Read for Box<T>where
T: Read + ?Sized,
§fn read(&mut self, buf: &mut [u8]) -> Result<usize, <Box<T> as Io>::Error>
fn read(&mut self, buf: &mut [u8]) -> Result<usize, <Box<T> as Io>::Error>
§fn read_exact(
&mut self,
buf: &mut [u8],
) -> Result<(), ReadExactError<Self::Error>>
fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>
buf.§impl<C> RequestConnection for Box<C>where
C: RequestConnection + ?Sized,
impl<C> RequestConnection for Box<C>where
C: RequestConnection + ?Sized,
§type Buf = <C as RequestConnection>::Buf
type Buf = <C as RequestConnection>::Buf
§fn send_request_with_reply<R>(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>,
) -> Result<Cookie<'_, Box<C>, R>, ConnectionError>where
R: TryParse,
fn send_request_with_reply<R>(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>,
) -> Result<Cookie<'_, Box<C>, R>, ConnectionError>where
R: TryParse,
§fn send_trait_request_with_reply<R>(
&self,
request: R,
) -> Result<Cookie<'_, Box<C>, <R as ReplyRequest>::Reply>, ConnectionError>where
R: ReplyRequest,
fn send_trait_request_with_reply<R>(
&self,
request: R,
) -> Result<Cookie<'_, Box<C>, <R as ReplyRequest>::Reply>, ConnectionError>where
R: ReplyRequest,
§fn send_request_with_reply_with_fds<R>(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>,
) -> Result<CookieWithFds<'_, Box<C>, R>, ConnectionError>where
R: TryParseFd,
fn send_request_with_reply_with_fds<R>(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>,
) -> Result<CookieWithFds<'_, Box<C>, R>, ConnectionError>where
R: TryParseFd,
§fn send_trait_request_with_reply_with_fds<R>(
&self,
request: R,
) -> Result<CookieWithFds<'_, Box<C>, <R as ReplyFDsRequest>::Reply>, ConnectionError>where
R: ReplyFDsRequest,
fn send_trait_request_with_reply_with_fds<R>(
&self,
request: R,
) -> Result<CookieWithFds<'_, Box<C>, <R as ReplyFDsRequest>::Reply>, ConnectionError>where
R: ReplyFDsRequest,
§fn send_request_without_reply(
&self,
bufs: &[IoSlice<'_>],
fds: Vec<OwnedFd>,
) -> Result<VoidCookie<'_, Box<C>>, ConnectionError>
fn send_request_without_reply( &self, bufs: &[IoSlice<'_>], fds: Vec<OwnedFd>, ) -> Result<VoidCookie<'_, Box<C>>, ConnectionError>
§fn send_trait_request_without_reply<R>(
&self,
request: R,
) -> Result<VoidCookie<'_, Box<C>>, ConnectionError>where
R: VoidRequest,
fn send_trait_request_without_reply<R>(
&self,
request: R,
) -> Result<VoidCookie<'_, Box<C>>, ConnectionError>where
R: VoidRequest,
§fn discard_reply(&self, sequence: u64, kind: RequestKind, mode: DiscardMode)
fn discard_reply(&self, sequence: u64, kind: RequestKind, mode: DiscardMode)
§fn prefetch_extension_information(
&self,
extension_name: &'static str,
) -> Result<(), ConnectionError>
fn prefetch_extension_information( &self, extension_name: &'static str, ) -> Result<(), ConnectionError>
§fn extension_information(
&self,
extension_name: &'static str,
) -> Result<Option<ExtensionInformation>, ConnectionError>
fn extension_information( &self, extension_name: &'static str, ) -> Result<Option<ExtensionInformation>, ConnectionError>
§fn wait_for_reply_or_error(
&self,
sequence: u64,
) -> Result<<Box<C> as RequestConnection>::Buf, ReplyError>
fn wait_for_reply_or_error( &self, sequence: u64, ) -> Result<<Box<C> as RequestConnection>::Buf, ReplyError>
§fn wait_for_reply_or_raw_error(
&self,
sequence: u64,
) -> Result<ReplyOrError<<Box<C> as RequestConnection>::Buf>, ConnectionError>
fn wait_for_reply_or_raw_error( &self, sequence: u64, ) -> Result<ReplyOrError<<Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn wait_for_reply(
&self,
sequence: u64,
) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
fn wait_for_reply( &self, sequence: u64, ) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn wait_for_reply_with_fds(
&self,
sequence: u64,
) -> Result<(<Box<C> as RequestConnection>::Buf, Vec<OwnedFd>), ReplyError>
fn wait_for_reply_with_fds( &self, sequence: u64, ) -> Result<(<Box<C> as RequestConnection>::Buf, Vec<OwnedFd>), ReplyError>
§fn wait_for_reply_with_fds_raw(
&self,
sequence: u64,
) -> Result<ReplyOrError<(<Box<C> as RequestConnection>::Buf, Vec<OwnedFd>), <Box<C> as RequestConnection>::Buf>, ConnectionError>
fn wait_for_reply_with_fds_raw( &self, sequence: u64, ) -> Result<ReplyOrError<(<Box<C> as RequestConnection>::Buf, Vec<OwnedFd>), <Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn check_for_error(&self, sequence: u64) -> Result<(), ReplyError>
fn check_for_error(&self, sequence: u64) -> Result<(), ReplyError>
§fn check_for_raw_error(
&self,
sequence: u64,
) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
fn check_for_raw_error( &self, sequence: u64, ) -> Result<Option<<Box<C> as RequestConnection>::Buf>, ConnectionError>
§fn prefetch_maximum_request_bytes(&self)
fn prefetch_maximum_request_bytes(&self)
§fn maximum_request_bytes(&self) -> usize
fn maximum_request_bytes(&self) -> usize
§fn parse_error(&self, error: &[u8]) -> Result<X11Error, ParseError>
fn parse_error(&self, error: &[u8]) -> Result<X11Error, ParseError>
§fn parse_event(&self, event: &[u8]) -> Result<Event, ParseError>
fn parse_event(&self, event: &[u8]) -> Result<Event, ParseError>
source§impl<R> RngCore for Box<R>
impl<R> RngCore for Box<R>
source§fn fill_bytes(&mut self, dest: &mut [u8])
fn fill_bytes(&mut self, dest: &mut [u8])
dest with random data. Read more§impl ScheduleLabel for Box<dyn ScheduleLabel>
impl ScheduleLabel for Box<dyn ScheduleLabel>
§fn inner_type_id(&self) -> TypeId
fn inner_type_id(&self) -> TypeId
1.0.0 · source§impl<S> Seek for Box<S>
impl<S> Seek for Box<S>
source§fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
source§fn stream_position(&mut self) -> Result<u64, Error>
fn stream_position(&mut self) -> Result<u64, Error>
1.55.0 · source§fn rewind(&mut self) -> Result<(), Error>
fn rewind(&mut self) -> Result<(), Error>
§impl<T> Seek for Box<T>where
T: Seek + ?Sized,
impl<T> Seek for Box<T>where
T: Seek + ?Sized,
source§impl<T> Serialize for Box<T>
impl<T> Serialize for Box<T>
source§fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
source§impl<T> Serializer for Box<T>where
T: Serializer + ?Sized,
impl<T> Serializer for Box<T>where
T: Serializer + ?Sized,
fn erased_serialize_bool(&mut self, v: bool)
fn erased_serialize_i8(&mut self, v: i8)
fn erased_serialize_i16(&mut self, v: i16)
fn erased_serialize_i32(&mut self, v: i32)
fn erased_serialize_i64(&mut self, v: i64)
fn erased_serialize_i128(&mut self, v: i128)
fn erased_serialize_u8(&mut self, v: u8)
fn erased_serialize_u16(&mut self, v: u16)
fn erased_serialize_u32(&mut self, v: u32)
fn erased_serialize_u64(&mut self, v: u64)
fn erased_serialize_u128(&mut self, v: u128)
fn erased_serialize_f32(&mut self, v: f32)
fn erased_serialize_f64(&mut self, v: f64)
fn erased_serialize_char(&mut self, v: char)
fn erased_serialize_str(&mut self, v: &str)
fn erased_serialize_bytes(&mut self, v: &[u8])
fn erased_serialize_none(&mut self)
fn erased_serialize_some(&mut self, value: &dyn Serialize)
fn erased_serialize_unit(&mut self)
fn erased_serialize_unit_struct(&mut self, name: &'static str)
fn erased_serialize_unit_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, )
fn erased_serialize_newtype_struct( &mut self, name: &'static str, value: &dyn Serialize, )
fn erased_serialize_newtype_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, value: &dyn Serialize, )
fn erased_serialize_seq( &mut self, len: Option<usize>, ) -> Result<&mut dyn SerializeSeq, ErrorImpl>
fn erased_serialize_tuple( &mut self, len: usize, ) -> Result<&mut dyn SerializeTuple, ErrorImpl>
fn erased_serialize_tuple_struct( &mut self, name: &'static str, len: usize, ) -> Result<&mut dyn SerializeTupleStruct, ErrorImpl>
fn erased_serialize_tuple_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<&mut dyn SerializeTupleVariant, ErrorImpl>
fn erased_serialize_map( &mut self, len: Option<usize>, ) -> Result<&mut dyn SerializeMap, ErrorImpl>
fn erased_serialize_struct( &mut self, name: &'static str, len: usize, ) -> Result<&mut dyn SerializeStruct, ErrorImpl>
fn erased_serialize_struct_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<&mut dyn SerializeStructVariant, ErrorImpl>
fn erased_is_human_readable(&self) -> bool
source§impl<'a> Serializer for Box<dyn Serializer + 'a>
impl<'a> Serializer for Box<dyn Serializer + 'a>
fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
fn erased_serialize_unit_struct( &mut self, name: &'static str, ) -> Result<Ok, Error>
fn erased_serialize_unit_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, ) -> Result<Ok, Error>
fn erased_serialize_newtype_struct( &mut self, name: &'static str, v: &dyn Serialize, ) -> Result<Ok, Error>
fn erased_serialize_newtype_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, v: &dyn Serialize, ) -> Result<Ok, Error>
fn erased_serialize_seq(&mut self, len: Option<usize>) -> Result<Seq<'_>, Error>
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
fn erased_serialize_tuple_struct( &mut self, name: &'static str, len: usize, ) -> Result<TupleStruct<'_>, Error>
fn erased_serialize_tuple_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<TupleVariant<'_>, Error>
fn erased_serialize_map(&mut self, len: Option<usize>) -> Result<Map<'_>, Error>
fn erased_serialize_struct( &mut self, name: &'static str, len: usize, ) -> Result<Struct<'_>, Error>
fn erased_serialize_struct_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
source§impl<'a> Serializer for Box<dyn Serializer + Send + 'a>
impl<'a> Serializer for Box<dyn Serializer + Send + 'a>
fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
fn erased_serialize_unit_struct( &mut self, name: &'static str, ) -> Result<Ok, Error>
fn erased_serialize_unit_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, ) -> Result<Ok, Error>
fn erased_serialize_newtype_struct( &mut self, name: &'static str, v: &dyn Serialize, ) -> Result<Ok, Error>
fn erased_serialize_newtype_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, v: &dyn Serialize, ) -> Result<Ok, Error>
fn erased_serialize_seq(&mut self, len: Option<usize>) -> Result<Seq<'_>, Error>
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
fn erased_serialize_tuple_struct( &mut self, name: &'static str, len: usize, ) -> Result<TupleStruct<'_>, Error>
fn erased_serialize_tuple_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<TupleVariant<'_>, Error>
fn erased_serialize_map(&mut self, len: Option<usize>) -> Result<Map<'_>, Error>
fn erased_serialize_struct( &mut self, name: &'static str, len: usize, ) -> Result<Struct<'_>, Error>
fn erased_serialize_struct_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
source§impl<'a> Serializer for Box<dyn Serializer + Send + Sync + 'a>
impl<'a> Serializer for Box<dyn Serializer + Send + Sync + 'a>
fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
fn erased_serialize_unit_struct( &mut self, name: &'static str, ) -> Result<Ok, Error>
fn erased_serialize_unit_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, ) -> Result<Ok, Error>
fn erased_serialize_newtype_struct( &mut self, name: &'static str, v: &dyn Serialize, ) -> Result<Ok, Error>
fn erased_serialize_newtype_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, v: &dyn Serialize, ) -> Result<Ok, Error>
fn erased_serialize_seq(&mut self, len: Option<usize>) -> Result<Seq<'_>, Error>
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
fn erased_serialize_tuple_struct( &mut self, name: &'static str, len: usize, ) -> Result<TupleStruct<'_>, Error>
fn erased_serialize_tuple_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<TupleVariant<'_>, Error>
fn erased_serialize_map(&mut self, len: Option<usize>) -> Result<Map<'_>, Error>
fn erased_serialize_struct( &mut self, name: &'static str, len: usize, ) -> Result<Struct<'_>, Error>
fn erased_serialize_struct_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
source§impl<'a> Serializer for Box<dyn Serializer + Sync + 'a>
impl<'a> Serializer for Box<dyn Serializer + Sync + 'a>
fn erased_serialize_bool(&mut self, v: bool) -> Result<Ok, Error>
fn erased_serialize_i8(&mut self, v: i8) -> Result<Ok, Error>
fn erased_serialize_i16(&mut self, v: i16) -> Result<Ok, Error>
fn erased_serialize_i32(&mut self, v: i32) -> Result<Ok, Error>
fn erased_serialize_i64(&mut self, v: i64) -> Result<Ok, Error>
fn erased_serialize_i128(&mut self, v: i128) -> Result<Ok, Error>
fn erased_serialize_u8(&mut self, v: u8) -> Result<Ok, Error>
fn erased_serialize_u16(&mut self, v: u16) -> Result<Ok, Error>
fn erased_serialize_u32(&mut self, v: u32) -> Result<Ok, Error>
fn erased_serialize_u64(&mut self, v: u64) -> Result<Ok, Error>
fn erased_serialize_u128(&mut self, v: u128) -> Result<Ok, Error>
fn erased_serialize_f32(&mut self, v: f32) -> Result<Ok, Error>
fn erased_serialize_f64(&mut self, v: f64) -> Result<Ok, Error>
fn erased_serialize_char(&mut self, v: char) -> Result<Ok, Error>
fn erased_serialize_str(&mut self, v: &str) -> Result<Ok, Error>
fn erased_serialize_bytes(&mut self, v: &[u8]) -> Result<Ok, Error>
fn erased_serialize_none(&mut self) -> Result<Ok, Error>
fn erased_serialize_some(&mut self, v: &dyn Serialize) -> Result<Ok, Error>
fn erased_serialize_unit(&mut self) -> Result<Ok, Error>
fn erased_serialize_unit_struct( &mut self, name: &'static str, ) -> Result<Ok, Error>
fn erased_serialize_unit_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, ) -> Result<Ok, Error>
fn erased_serialize_newtype_struct( &mut self, name: &'static str, v: &dyn Serialize, ) -> Result<Ok, Error>
fn erased_serialize_newtype_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, v: &dyn Serialize, ) -> Result<Ok, Error>
fn erased_serialize_seq(&mut self, len: Option<usize>) -> Result<Seq<'_>, Error>
fn erased_serialize_tuple(&mut self, len: usize) -> Result<Tuple<'_>, Error>
fn erased_serialize_tuple_struct( &mut self, name: &'static str, len: usize, ) -> Result<TupleStruct<'_>, Error>
fn erased_serialize_tuple_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<TupleVariant<'_>, Error>
fn erased_serialize_map(&mut self, len: Option<usize>) -> Result<Map<'_>, Error>
fn erased_serialize_struct( &mut self, name: &'static str, len: usize, ) -> Result<Struct<'_>, Error>
fn erased_serialize_struct_variant( &mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize, ) -> Result<StructVariant<'_>, Error>
fn erased_is_human_readable(&self) -> bool
§impl<S, Request> Service<Request> for Box<S>where
S: Service<Request> + ?Sized,
impl<S, Request> Service<Request> for Box<S>where
S: Service<Request> + ?Sized,
§impl<T> ShaderSize for Box<T>where
T: ShaderSize + ?Sized,
impl<T> ShaderSize for Box<T>where
T: ShaderSize + ?Sized,
§const SHADER_SIZE: NonZero<u64> = T::SHADER_SIZE
const SHADER_SIZE: NonZero<u64> = T::SHADER_SIZE
ShaderType::min_size])§impl<T> ShaderType for Box<T>where
T: ShaderType + ?Sized,
impl<T> ShaderType for Box<T>where
T: ShaderType + ?Sized,
§fn assert_uniform_compat()
fn assert_uniform_compat()
Self meets the requirements of the
uniform address space restrictions on stored values and the
uniform address space layout constraints Read more§impl<S, Item> Sink<Item> for Box<S>
impl<S, Item> Sink<Item> for Box<S>
§fn poll_ready(
self: Pin<&mut Box<S>>,
cx: &mut Context<'_>,
) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
fn poll_ready( self: Pin<&mut Box<S>>, cx: &mut Context<'_>, ) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
Sink to receive a value. Read more§fn start_send(
self: Pin<&mut Box<S>>,
item: Item,
) -> Result<(), <Box<S> as Sink<Item>>::Error>
fn start_send( self: Pin<&mut Box<S>>, item: Item, ) -> Result<(), <Box<S> as Sink<Item>>::Error>
poll_ready which returned Poll::Ready(Ok(())). Read more§impl<T> Source for Box<T>where
T: Source + ?Sized,
impl<T> Source for Box<T>where
T: Source + ?Sized,
§impl<T> Source for Box<T>where
T: Source + ?Sized,
impl<T> Source for Box<T>where
T: Source + ?Sized,
§impl<S> Stream for Box<S>
impl<S> Stream for Box<S>
§impl<S> Subscriber for Box<S>where
S: Subscriber + ?Sized,
impl<S> Subscriber for Box<S>where
S: Subscriber + ?Sized,
§fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
§fn max_level_hint(&self) -> Option<LevelFilter>
fn max_level_hint(&self) -> Option<LevelFilter>
Subscriber will
enable, or None, if the subscriber does not implement level-based
filtering or chooses not to implement this method. Read more§fn record_follows_from(&self, span: &Id, follows: &Id)
fn record_follows_from(&self, span: &Id, follows: &Id)
§fn event_enabled(&self, event: &Event<'_>) -> bool
fn event_enabled(&self, event: &Event<'_>) -> bool
Event] should be recorded. Read more§fn clone_span(&self, id: &Id) -> Id
fn clone_span(&self, id: &Id) -> Id
§fn drop_span(&self, id: Id)
fn drop_span(&self, id: Id)
Subscriber::try_close instead§fn current_span(&self) -> Current
fn current_span(&self) -> Current
§unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()>
unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()>
self is the same type as the provided TypeId, returns an untyped
*const pointer to that type. Otherwise, returns None. Read more§fn on_register_dispatch(&self, subscriber: &Dispatch)
fn on_register_dispatch(&self, subscriber: &Dispatch)
Dispatch]. Read more1.43.0 · source§impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]>
impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]>
source§fn try_from(
boxed_slice: Box<[T]>,
) -> Result<Box<[T; N]>, <Box<[T; N]> as TryFrom<Box<[T]>>>::Error>
fn try_from( boxed_slice: Box<[T]>, ) -> Result<Box<[T; N]>, <Box<[T; N]> as TryFrom<Box<[T]>>>::Error>
Attempts to convert a Box<[T]> into a Box<[T; N]>.
The conversion occurs in-place and does not require a new memory allocation.
§Errors
Returns the old Box<[T]> in the Err variant if
boxed_slice.len() does not equal N.
1.66.0 · source§impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>
impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]>
source§fn try_from(
vec: Vec<T>,
) -> Result<Box<[T; N]>, <Box<[T; N]> as TryFrom<Vec<T>>>::Error>
fn try_from( vec: Vec<T>, ) -> Result<Box<[T; N]>, <Box<[T; N]> as TryFrom<Vec<T>>>::Error>
Attempts to convert a Vec<T> into a Box<[T; N]>.
Like Vec::into_boxed_slice, this is in-place if vec.capacity() == N,
but will require a reallocation otherwise.
§Errors
Returns the original Vec<T> in the Err variant if
boxed_slice.len() does not equal N.
§Examples
This can be used with vec! to create an array on the heap:
let state: Box<[f32; 100]> = vec![1.0; 100].try_into().unwrap();
assert_eq!(state.len(), 100);§impl<T> TurboCore for Box<T>
impl<T> TurboCore for Box<T>
§fn fill_bytes(&self, buffer: &mut [u8])
fn fill_bytes(&self, buffer: &mut [u8])
§impl<T> Write for Box<T>where
T: Write + ?Sized,
impl<T> Write for Box<T>where
T: Write + ?Sized,
§fn write(&mut self, buf: &[u8]) -> Result<usize, <Box<T> as Io>::Error>
fn write(&mut self, buf: &[u8]) -> Result<usize, <Box<T> as Io>::Error>
§fn flush(&mut self) -> Result<(), <Box<T> as Io>::Error>
fn flush(&mut self) -> Result<(), <Box<T> as Io>::Error>
§impl<T> Write for Box<T>
impl<T> Write for Box<T>
§fn poll_write(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<Result<usize, Error>>
fn poll_write( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>
buf into the destination. Read more§fn poll_write_vectored(
self: Pin<&mut Box<T>>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>],
) -> Poll<Result<usize, Error>>
fn poll_write_vectored( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>
poll_write, except that it writes from a slice of buffers.§fn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
poll_write_vectored
implementation. Read more1.0.0 · source§impl<W> Write for Box<W>
impl<W> Write for Box<W>
source§fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
source§fn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
can_vector)source§fn flush(&mut self) -> Result<(), Error>
fn flush(&mut self) -> Result<(), Error>
source§fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
source§fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
§impl<T> WriteColor for Box<T>where
T: WriteColor + ?Sized,
impl<T> WriteColor for Box<T>where
T: WriteColor + ?Sized,
§fn supports_color(&self) -> bool
fn supports_color(&self) -> bool
§fn supports_hyperlinks(&self) -> bool
fn supports_hyperlinks(&self) -> bool
§fn set_color(&mut self, spec: &ColorSpec) -> Result<(), Error>
fn set_color(&mut self, spec: &ColorSpec) -> Result<(), Error>
§fn set_hyperlink(&mut self, link: &HyperlinkSpec<'_>) -> Result<(), Error>
fn set_hyperlink(&mut self, link: &HyperlinkSpec<'_>) -> Result<(), Error>
§fn reset(&mut self) -> Result<(), Error>
fn reset(&mut self) -> Result<(), Error>
§fn is_synchronous(&self) -> bool
fn is_synchronous(&self) -> bool
false. Read more§impl<T> WriteInto for Box<T>where
T: WriteInto + ?Sized,
impl<T> WriteInto for Box<T>where
T: WriteInto + ?Sized,
fn write_into<B>(&self, writer: &mut Writer<B>)where
B: BufferMut,
impl<T, U, A> CoerceUnsized<Box<U, A>> for Box<T, A>
impl<R> CryptoRng for Box<R>
impl<T, A> DerefPure for Box<T, A>
impl<T, U> DispatchFromDyn<Box<U>> for Box<T>
impl<T, A> Eq for Box<T, A>
impl<I, A> FusedIterator for Box<I, A>
impl<T> SecureCore for Box<T>
impl<'a, T> Sequence<'a> for Box<T>where
T: Sequence<'a>,
impl<T> StableDeref for Box<T>where
T: ?Sized,
impl<T, A> Unpin for Box<T, A>
impl<T> ZeroableInOption for Box<T>where
T: ?Sized,
impl<Z> ZeroizeOnDrop for Box<[Z]>where
Z: ZeroizeOnDrop,
Auto Trait Implementations§
impl<T, A> Freeze for Box<T, A>
impl<T, A> RefUnwindSafe for Box<T, A>
impl<T, A> Send for Box<T, A>
impl<T, A> Sync for Box<T, A>
impl<T, A> UnwindSafe for Box<T, A>
Blanket Implementations§
§impl<T, U> AsBindGroupShaderType<U> for T
impl<T, U> AsBindGroupShaderType<U> for T
§fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U
fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U
T [ShaderType] for self. When used in [AsBindGroup]
derives, it is safe to assume that all images in self exist.§impl<A, T> AsBits<T> for A
impl<A, T> AsBits<T> for A
§impl<A, T> AsMutBits<T> for A
impl<A, T> AsMutBits<T> for A
§fn as_mut_bits<O>(&mut self) -> &mut BitSlice<T, O> ⓘwhere
O: BitOrder,
fn as_mut_bits<O>(&mut self) -> &mut BitSlice<T, O> ⓘwhere
O: BitOrder,
self as a mutable bit-slice region with the O ordering.§fn try_as_mut_bits<O>(&mut self) -> Result<&mut BitSlice<T, O>, BitSpanError<T>>where
O: BitOrder,
fn try_as_mut_bits<O>(&mut self) -> Result<&mut BitSlice<T, O>, BitSpanError<T>>where
O: BitOrder,
§impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
§impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
§impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
§fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere
Self: Unpin,
fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere
Self: Unpin,
§fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>,
) -> ReadUntilFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>,
) -> ReadUntilFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> ⓘwhere
Self: Unpin,
buf until a newline (the 0xA byte) or EOF is found. Read more§impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
§fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere
Self: Unpin,
fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere
Self: Unpin,
§fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>,
) -> ReadUntilFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>,
) -> ReadUntilFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> ⓘwhere
Self: Unpin,
buf until a newline (the 0xA byte) or EOF is found. Read more§impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
§fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>,
) -> ReadUntil<'a, Self>where
Self: Unpin,
fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>,
) -> ReadUntil<'a, Self>where
Self: Unpin,
§fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self>where
Self: Unpin,
fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self>where
Self: Unpin,
§fn split(self, byte: u8) -> Split<Self>
fn split(self, byte: u8) -> Split<Self>
byte. Read more§fn fill_buf(&mut self) -> FillBuf<'_, Self>where
Self: Unpin,
fn fill_buf(&mut self) -> FillBuf<'_, Self>where
Self: Unpin,
§fn lines(self) -> Lines<Self>where
Self: Sized,
fn lines(self) -> Lines<Self>where
Self: Sized,
BufRead::lines. Read more§impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
impl<R> AsyncBufReadExt for Rwhere
R: AsyncBufRead + ?Sized,
§fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere
Self: Unpin,
fn fill_buf(&mut self) -> FillBuf<'_, Self> ⓘwhere
Self: Unpin,
§fn consume_unpin(&mut self, amt: usize)where
Self: Unpin,
fn consume_unpin(&mut self, amt: usize)where
Self: Unpin,
§fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>,
) -> ReadUntil<'a, Self> ⓘwhere
Self: Unpin,
fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>,
) -> ReadUntil<'a, Self> ⓘwhere
Self: Unpin,
buf until the delimiter byte or EOF is reached.
This method is the async equivalent to BufRead::read_until. Read more§fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self> ⓘwhere
Self: Unpin,
fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self> ⓘwhere
Self: Unpin,
buf until a newline (the 0xA byte) or EOF is reached,
This method is the async equivalent to BufRead::read_line. Read more§fn lines(self) -> Lines<Self>where
Self: Sized,
fn lines(self) -> Lines<Self>where
Self: Sized,
BufRead::lines. Read more§impl<R> AsyncReadExt for R
impl<R> AsyncReadExt for R
§fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>],
) -> ReadVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>],
) -> ReadVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8>,
) -> ReadToEndFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8>,
) -> ReadToEndFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String,
) -> ReadToStringFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String,
) -> ReadToStringFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> ⓘwhere
Self: Unpin,
buf. Read more§fn take(self, limit: u64) -> Take<Self>where
Self: Sized,
fn take(self, limit: u64) -> Take<Self>where
Self: Sized,
limit bytes from it. Read more§impl<R> AsyncReadExt for R
impl<R> AsyncReadExt for R
§fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>],
) -> ReadVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>],
) -> ReadVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8>,
) -> ReadToEndFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8>,
) -> ReadToEndFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String,
) -> ReadToStringFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String,
) -> ReadToStringFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> ⓘwhere
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> ⓘwhere
Self: Unpin,
buf. Read more§fn take(self, limit: u64) -> Take<Self>where
Self: Sized,
fn take(self, limit: u64) -> Take<Self>where
Self: Sized,
limit bytes from it. Read more§impl<R> AsyncReadExt for Rwhere
R: AsyncRead + ?Sized,
impl<R> AsyncReadExt for Rwhere
R: AsyncRead + ?Sized,
§fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self>where
Self: Unpin,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self>where
Self: Unpin,
§fn read_buf<'a, B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B>
fn read_buf<'a, B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B>
§fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self>where
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self>where
Self: Unpin,
buf. Read more§fn read_u8(&mut self) -> ReadU8<&mut Self>where
Self: Unpin,
fn read_u8(&mut self) -> ReadU8<&mut Self>where
Self: Unpin,
§fn read_i8(&mut self) -> ReadI8<&mut Self>where
Self: Unpin,
fn read_i8(&mut self) -> ReadI8<&mut Self>where
Self: Unpin,
§fn read_u16(&mut self) -> ReadU16<&mut Self>where
Self: Unpin,
fn read_u16(&mut self) -> ReadU16<&mut Self>where
Self: Unpin,
§fn read_i16(&mut self) -> ReadI16<&mut Self>where
Self: Unpin,
fn read_i16(&mut self) -> ReadI16<&mut Self>where
Self: Unpin,
§fn read_u32(&mut self) -> ReadU32<&mut Self>where
Self: Unpin,
fn read_u32(&mut self) -> ReadU32<&mut Self>where
Self: Unpin,
§fn read_i32(&mut self) -> ReadI32<&mut Self>where
Self: Unpin,
fn read_i32(&mut self) -> ReadI32<&mut Self>where
Self: Unpin,
§fn read_u64(&mut self) -> ReadU64<&mut Self>where
Self: Unpin,
fn read_u64(&mut self) -> ReadU64<&mut Self>where
Self: Unpin,
§fn read_i64(&mut self) -> ReadI64<&mut Self>where
Self: Unpin,
fn read_i64(&mut self) -> ReadI64<&mut Self>where
Self: Unpin,
§fn read_u128(&mut self) -> ReadU128<&mut Self>where
Self: Unpin,
fn read_u128(&mut self) -> ReadU128<&mut Self>where
Self: Unpin,
§fn read_i128(&mut self) -> ReadI128<&mut Self>where
Self: Unpin,
fn read_i128(&mut self) -> ReadI128<&mut Self>where
Self: Unpin,
§fn read_f32(&mut self) -> ReadF32<&mut Self>where
Self: Unpin,
fn read_f32(&mut self) -> ReadF32<&mut Self>where
Self: Unpin,
§fn read_f64(&mut self) -> ReadF64<&mut Self>where
Self: Unpin,
fn read_f64(&mut self) -> ReadF64<&mut Self>where
Self: Unpin,
§fn read_u16_le(&mut self) -> ReadU16Le<&mut Self>where
Self: Unpin,
fn read_u16_le(&mut self) -> ReadU16Le<&mut Self>where
Self: Unpin,
§fn read_i16_le(&mut self) -> ReadI16Le<&mut Self>where
Self: Unpin,
fn read_i16_le(&mut self) -> ReadI16Le<&mut Self>where
Self: Unpin,
§fn read_u32_le(&mut self) -> ReadU32Le<&mut Self>where
Self: Unpin,
fn read_u32_le(&mut self) -> ReadU32Le<&mut Self>where
Self: Unpin,
§fn read_i32_le(&mut self) -> ReadI32Le<&mut Self>where
Self: Unpin,
fn read_i32_le(&mut self) -> ReadI32Le<&mut Self>where
Self: Unpin,
§fn read_u64_le(&mut self) -> ReadU64Le<&mut Self>where
Self: Unpin,
fn read_u64_le(&mut self) -> ReadU64Le<&mut Self>where
Self: Unpin,
§fn read_i64_le(&mut self) -> ReadI64Le<&mut Self>where
Self: Unpin,
fn read_i64_le(&mut self) -> ReadI64Le<&mut Self>where
Self: Unpin,
§fn read_u128_le(&mut self) -> ReadU128Le<&mut Self>where
Self: Unpin,
fn read_u128_le(&mut self) -> ReadU128Le<&mut Self>where
Self: Unpin,
§fn read_i128_le(&mut self) -> ReadI128Le<&mut Self>where
Self: Unpin,
fn read_i128_le(&mut self) -> ReadI128Le<&mut Self>where
Self: Unpin,
§fn read_f32_le(&mut self) -> ReadF32Le<&mut Self>where
Self: Unpin,
fn read_f32_le(&mut self) -> ReadF32Le<&mut Self>where
Self: Unpin,
§fn read_f64_le(&mut self) -> ReadF64Le<&mut Self>where
Self: Unpin,
fn read_f64_le(&mut self) -> ReadF64Le<&mut Self>where
Self: Unpin,
§fn read_to_end<'a>(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self>where
Self: Unpin,
fn read_to_end<'a>(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self>where
Self: Unpin,
buf. Read more§fn read_to_string<'a>(
&'a mut self,
dst: &'a mut String,
) -> ReadToString<'a, Self>where
Self: Unpin,
fn read_to_string<'a>(
&'a mut self,
dst: &'a mut String,
) -> ReadToString<'a, Self>where
Self: Unpin,
buf. Read more§impl<R> AsyncReadExt for R
impl<R> AsyncReadExt for R
§fn chain<R>(self, next: R) -> Chain<Self, R>
fn chain<R>(self, next: R) -> Chain<Self, R>
§fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> ⓘwhere
Self: Unpin,
fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> ⓘwhere
Self: Unpin,
buf in asynchronous
manner, returning a future type. Read more§fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>],
) -> ReadVectored<'a, Self> ⓘwhere
Self: Unpin,
fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>],
) -> ReadVectored<'a, Self> ⓘwhere
Self: Unpin,
AsyncRead into bufs using vectored
IO operations. Read more§fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> ⓘwhere
Self: Unpin,
fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> ⓘwhere
Self: Unpin,
buf,
returning an error if end of file (EOF) is hit sooner. Read more§fn read_to_end<'a>(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_end<'a>(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self> ⓘwhere
Self: Unpin,
AsyncRead. Read more§fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String,
) -> ReadToString<'a, Self> ⓘwhere
Self: Unpin,
fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String,
) -> ReadToString<'a, Self> ⓘwhere
Self: Unpin,
AsyncRead. Read more§fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>)where
Self: Sized + AsyncWrite,
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>)where
Self: Sized + AsyncWrite,
§impl<S> AsyncSeekExt for S
impl<S> AsyncSeekExt for S
§impl<S> AsyncSeekExt for S
impl<S> AsyncSeekExt for S
§impl<S> AsyncSeekExt for Swhere
S: AsyncSeek + ?Sized,
impl<S> AsyncSeekExt for Swhere
S: AsyncSeek + ?Sized,
§fn seek(&mut self, pos: SeekFrom) -> Seek<'_, Self>where
Self: Unpin,
fn seek(&mut self, pos: SeekFrom) -> Seek<'_, Self>where
Self: Unpin,
§fn rewind(&mut self) -> Seek<'_, Self>where
Self: Unpin,
fn rewind(&mut self) -> Seek<'_, Self>where
Self: Unpin,
§fn stream_position(&mut self) -> Seek<'_, Self>where
Self: Unpin,
fn stream_position(&mut self) -> Seek<'_, Self>where
Self: Unpin,
§impl<S> AsyncSeekExt for S
impl<S> AsyncSeekExt for S
§fn seek(&mut self, pos: SeekFrom) -> Seek<'_, Self> ⓘwhere
Self: Unpin,
fn seek(&mut self, pos: SeekFrom) -> Seek<'_, Self> ⓘwhere
Self: Unpin,
§fn stream_position(&mut self) -> Seek<'_, Self> ⓘwhere
Self: Unpin,
fn stream_position(&mut self) -> Seek<'_, Self> ⓘwhere
Self: Unpin,
§impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
§fn write<'a>(&'a mut self, buf: &'a [u8]) -> WriteFuture<'a, Self> ⓘwhere
Self: Unpin,
fn write<'a>(&'a mut self, buf: &'a [u8]) -> WriteFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>],
) -> WriteVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>],
) -> WriteVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> WriteAllFuture<'a, Self> ⓘwhere
Self: Unpin,
fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> WriteAllFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn flush(&mut self) -> FlushFuture<'_, Self> ⓘwhere
Self: Unpin,
fn flush(&mut self) -> FlushFuture<'_, Self> ⓘwhere
Self: Unpin,
§fn boxed_writer<'a>(self) -> Pin<Box<dyn AsyncWrite + Send + 'a>>
fn boxed_writer<'a>(self) -> Pin<Box<dyn AsyncWrite + Send + 'a>>
dyn AsyncWrite + Send + 'a. Read more§impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
§fn write<'a>(&'a mut self, buf: &'a [u8]) -> WriteFuture<'a, Self> ⓘwhere
Self: Unpin,
fn write<'a>(&'a mut self, buf: &'a [u8]) -> WriteFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>],
) -> WriteVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>],
) -> WriteVectoredFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> WriteAllFuture<'a, Self> ⓘwhere
Self: Unpin,
fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> WriteAllFuture<'a, Self> ⓘwhere
Self: Unpin,
§fn flush(&mut self) -> FlushFuture<'_, Self> ⓘwhere
Self: Unpin,
fn flush(&mut self) -> FlushFuture<'_, Self> ⓘwhere
Self: Unpin,
§fn boxed_writer<'a>(self) -> Pin<Box<dyn AsyncWrite + Send + 'a>>
fn boxed_writer<'a>(self) -> Pin<Box<dyn AsyncWrite + Send + 'a>>
dyn AsyncWrite + Send + 'a. Read more§impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
§fn write<'a>(&'a mut self, src: &'a [u8]) -> Write<'a, Self>where
Self: Unpin,
fn write<'a>(&'a mut self, src: &'a [u8]) -> Write<'a, Self>where
Self: Unpin,
§fn write_vectored<'a, 'b>(
&'a mut self,
bufs: &'a [IoSlice<'b>],
) -> WriteVectored<'a, 'b, Self>where
Self: Unpin,
fn write_vectored<'a, 'b>(
&'a mut self,
bufs: &'a [IoSlice<'b>],
) -> WriteVectored<'a, 'b, Self>where
Self: Unpin,
§fn write_buf<'a, B>(&'a mut self, src: &'a mut B) -> WriteBuf<'a, Self, B>
fn write_buf<'a, B>(&'a mut self, src: &'a mut B) -> WriteBuf<'a, Self, B>
§fn write_all_buf<'a, B>(
&'a mut self,
src: &'a mut B,
) -> WriteAllBuf<'a, Self, B>
fn write_all_buf<'a, B>( &'a mut self, src: &'a mut B, ) -> WriteAllBuf<'a, Self, B>
§fn write_all<'a>(&'a mut self, src: &'a [u8]) -> WriteAll<'a, Self>where
Self: Unpin,
fn write_all<'a>(&'a mut self, src: &'a [u8]) -> WriteAll<'a, Self>where
Self: Unpin,
§fn write_u8(&mut self, n: u8) -> WriteU8<&mut Self>where
Self: Unpin,
fn write_u8(&mut self, n: u8) -> WriteU8<&mut Self>where
Self: Unpin,
§fn write_i8(&mut self, n: i8) -> WriteI8<&mut Self>where
Self: Unpin,
fn write_i8(&mut self, n: i8) -> WriteI8<&mut Self>where
Self: Unpin,
§fn write_u16(&mut self, n: u16) -> WriteU16<&mut Self>where
Self: Unpin,
fn write_u16(&mut self, n: u16) -> WriteU16<&mut Self>where
Self: Unpin,
§fn write_i16(&mut self, n: i16) -> WriteI16<&mut Self>where
Self: Unpin,
fn write_i16(&mut self, n: i16) -> WriteI16<&mut Self>where
Self: Unpin,
§fn write_u32(&mut self, n: u32) -> WriteU32<&mut Self>where
Self: Unpin,
fn write_u32(&mut self, n: u32) -> WriteU32<&mut Self>where
Self: Unpin,
§fn write_i32(&mut self, n: i32) -> WriteI32<&mut Self>where
Self: Unpin,
fn write_i32(&mut self, n: i32) -> WriteI32<&mut Self>where
Self: Unpin,
§fn write_u64(&mut self, n: u64) -> WriteU64<&mut Self>where
Self: Unpin,
fn write_u64(&mut self, n: u64) -> WriteU64<&mut Self>where
Self: Unpin,
§fn write_i64(&mut self, n: i64) -> WriteI64<&mut Self>where
Self: Unpin,
fn write_i64(&mut self, n: i64) -> WriteI64<&mut Self>where
Self: Unpin,
§fn write_u128(&mut self, n: u128) -> WriteU128<&mut Self>where
Self: Unpin,
fn write_u128(&mut self, n: u128) -> WriteU128<&mut Self>where
Self: Unpin,
§fn write_i128(&mut self, n: i128) -> WriteI128<&mut Self>where
Self: Unpin,
fn write_i128(&mut self, n: i128) -> WriteI128<&mut Self>where
Self: Unpin,
§fn write_f32(&mut self, n: f32) -> WriteF32<&mut Self>where
Self: Unpin,
fn write_f32(&mut self, n: f32) -> WriteF32<&mut Self>where
Self: Unpin,
§fn write_f64(&mut self, n: f64) -> WriteF64<&mut Self>where
Self: Unpin,
fn write_f64(&mut self, n: f64) -> WriteF64<&mut Self>where
Self: Unpin,
§fn write_u16_le(&mut self, n: u16) -> WriteU16Le<&mut Self>where
Self: Unpin,
fn write_u16_le(&mut self, n: u16) -> WriteU16Le<&mut Self>where
Self: Unpin,
§fn write_i16_le(&mut self, n: i16) -> WriteI16Le<&mut Self>where
Self: Unpin,
fn write_i16_le(&mut self, n: i16) -> WriteI16Le<&mut Self>where
Self: Unpin,
§fn write_u32_le(&mut self, n: u32) -> WriteU32Le<&mut Self>where
Self: Unpin,
fn write_u32_le(&mut self, n: u32) -> WriteU32Le<&mut Self>where
Self: Unpin,
§fn write_i32_le(&mut self, n: i32) -> WriteI32Le<&mut Self>where
Self: Unpin,
fn write_i32_le(&mut self, n: i32) -> WriteI32Le<&mut Self>where
Self: Unpin,
§fn write_u64_le(&mut self, n: u64) -> WriteU64Le<&mut Self>where
Self: Unpin,
fn write_u64_le(&mut self, n: u64) -> WriteU64Le<&mut Self>where
Self: Unpin,
§fn write_i64_le(&mut self, n: i64) -> WriteI64Le<&mut Self>where
Self: Unpin,
fn write_i64_le(&mut self, n: i64) -> WriteI64Le<&mut Self>where
Self: Unpin,
§fn write_u128_le(&mut self, n: u128) -> WriteU128Le<&mut Self>where
Self: Unpin,
fn write_u128_le(&mut self, n: u128) -> WriteU128Le<&mut Self>where
Self: Unpin,
§fn write_i128_le(&mut self, n: i128) -> WriteI128Le<&mut Self>where
Self: Unpin,
fn write_i128_le(&mut self, n: i128) -> WriteI128Le<&mut Self>where
Self: Unpin,
§fn write_f32_le(&mut self, n: f32) -> WriteF32Le<&mut Self>where
Self: Unpin,
fn write_f32_le(&mut self, n: f32) -> WriteF32Le<&mut Self>where
Self: Unpin,
§fn write_f64_le(&mut self, n: f64) -> WriteF64Le<&mut Self>where
Self: Unpin,
fn write_f64_le(&mut self, n: f64) -> WriteF64Le<&mut Self>where
Self: Unpin,
§impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
impl<W> AsyncWriteExt for Wwhere
W: AsyncWrite + ?Sized,
§fn flush(&mut self) -> Flush<'_, Self> ⓘwhere
Self: Unpin,
fn flush(&mut self) -> Flush<'_, Self> ⓘwhere
Self: Unpin,
AsyncWrite. Read more§fn close(&mut self) -> Close<'_, Self> ⓘwhere
Self: Unpin,
fn close(&mut self) -> Close<'_, Self> ⓘwhere
Self: Unpin,
AsyncWrite.§fn write<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self> ⓘwhere
Self: Unpin,
fn write<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self> ⓘwhere
Self: Unpin,
buf into the object. Read more§fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>],
) -> WriteVectored<'a, Self> ⓘwhere
Self: Unpin,
fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>],
) -> WriteVectored<'a, Self> ⓘwhere
Self: Unpin,
bufs into the object using vectored
IO operations. Read more§impl<T> BodyExt for Twhere
T: Body + ?Sized,
impl<T> BodyExt for Twhere
T: Body + ?Sized,
§fn frame(&mut self) -> Frame<'_, Self> ⓘwhere
Self: Unpin,
fn frame(&mut self) -> Frame<'_, Self> ⓘwhere
Self: Unpin,
Frame, if any.§fn boxed_unsync(self) -> UnsyncBoxBody<Self::Data, Self::Error>
fn boxed_unsync(self) -> UnsyncBoxBody<Self::Data, Self::Error>
§fn collect(self) -> Collect<Self> ⓘwhere
Self: Sized,
fn collect(self) -> Collect<Self> ⓘwhere
Self: Sized,
Collected] body which will collect all the DATA frames
and trailers.§fn with_trailers<F>(self, trailers: F) -> WithTrailers<Self, F>
fn with_trailers<F>(self, trailers: F) -> WithTrailers<Self, F>
§fn into_data_stream(self) -> BodyDataStream<Self>where
Self: Sized,
fn into_data_stream(self) -> BodyDataStream<Self>where
Self: Sized,
BodyDataStream].source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> BufferedStreamExt for T
impl<T> BufferedStreamExt for T
§fn buffered_ordered(self, n: usize) -> BufferedOrdered<Self>
fn buffered_ordered(self, n: usize) -> BufferedOrdered<Self>
§fn buffered_unordered(self, n: usize) -> BufferUnordered<Self>
fn buffered_unordered(self, n: usize) -> BufferUnordered<Self>
§fn for_each_concurrent<Fut, F>(
self,
limit: usize,
f: F,
) -> ForEachConcurrent<Self, Fut, F>
fn for_each_concurrent<Fut, F>( self, limit: usize, f: F, ) -> ForEachConcurrent<Self, Fut, F>
§impl<T> BufferedTryStreamExt for Twhere
T: TryStream + ?Sized,
impl<T> BufferedTryStreamExt for Twhere
T: TryStream + ?Sized,
§fn try_buffered_ordered(self, n: usize) -> TryBufferedOrdered<Self>where
Self::Ok: TryFuture<Err = Self::Err>,
Self: Sized,
fn try_buffered_ordered(self, n: usize) -> TryBufferedOrdered<Self>where
Self::Ok: TryFuture<Err = Self::Err>,
Self: Sized,
§fn try_buffered_unordered(self, n: usize) -> TryBufferUnordered<Self>where
Self::Ok: TryFuture<Err = Self::Err>,
Self: Sized,
fn try_buffered_unordered(self, n: usize) -> TryBufferUnordered<Self>where
Self::Ok: TryFuture<Err = Self::Err>,
Self: Sized,
§impl<F> Callback for F
impl<F> Callback for F
§fn on_request(
self,
request: &Request<()>,
response: Response<()>,
) -> Result<Response<()>, Response<Option<String>>>
fn on_request( self, request: &Request<()>, response: Response<()>, ) -> Result<Response<()>, Response<Option<String>>>
§impl<T> CheckedSum<usize> for Twhere
T: IntoIterator<Item = usize>,
impl<T> CheckedSum<usize> for Twhere
T: IntoIterator<Item = usize>,
§fn checked_sum(self) -> Result<usize, Error>
fn checked_sum(self) -> Result<usize, Error>
§impl<'a, T> Choice<'a> for Twhere
T: Decode<'a> + FixedTag,
impl<'a, T> Choice<'a> for Twhere
T: Decode<'a> + FixedTag,
§fn can_decode(tag: Tag) -> bool
fn can_decode(tag: Tag) -> bool
Tag] decodable as a variant of this CHOICE?source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit)§impl<F> Command for F
impl<F> Command for F
§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
§impl<Marker, In, F> Condition<Marker, In> for Fwhere
F: Condition<Marker, In>,
impl<Marker, In, F> Condition<Marker, In> for Fwhere
F: Condition<Marker, In>,
§impl<C> ConnectionExt for Cwhere
C: RequestConnection + ?Sized,
impl<C> ConnectionExt for Cwhere
C: RequestConnection + ?Sized,
§fn bigreq_enable(
&self,
) -> Result<Cookie<'_, Self, EnableReply>, ConnectionError>
fn bigreq_enable( &self, ) -> Result<Cookie<'_, Self, EnableReply>, ConnectionError>
§impl<C> ConnectionExt for Cwhere
C: RequestConnection + ?Sized,
impl<C> ConnectionExt for Cwhere
C: RequestConnection + ?Sized,
fn ge_query_version( &self, client_major_version: u16, client_minor_version: u16, ) -> Result<Cookie<'_, Self, QueryVersionReply>, ConnectionError>
§impl<C> ConnectionExt for Cwhere
C: RequestConnection + ?Sized,
impl<C> ConnectionExt for Cwhere
C: RequestConnection + ?Sized,
§fn create_window<'c, 'input>(
&'c self,
depth: u8,
wid: u32,
parent: u32,
x: i16,
y: i16,
width: u16,
height: u16,
border_width: u16,
class: WindowClass,
visual: u32,
value_list: &'input CreateWindowAux,
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn create_window<'c, 'input>( &'c self, depth: u8, wid: u32, parent: u32, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: WindowClass, visual: u32, value_list: &'input CreateWindowAux, ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn change_window_attributes<'c, 'input>(
&'c self,
window: u32,
value_list: &'input ChangeWindowAttributesAux,
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn change_window_attributes<'c, 'input>( &'c self, window: u32, value_list: &'input ChangeWindowAttributesAux, ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn get_window_attributes(
&self,
window: u32,
) -> Result<Cookie<'_, Self, GetWindowAttributesReply>, ConnectionError>
fn get_window_attributes( &self, window: u32, ) -> Result<Cookie<'_, Self, GetWindowAttributesReply>, ConnectionError>
§fn destroy_window(
&self,
window: u32,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn destroy_window( &self, window: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn destroy_subwindows( &self, window: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn change_save_set(
&self,
mode: SetMode,
window: u32,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn change_save_set( &self, mode: SetMode, window: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn reparent_window(
&self,
window: u32,
parent: u32,
x: i16,
y: i16,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn reparent_window( &self, window: u32, parent: u32, x: i16, y: i16, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn map_window(
&self,
window: u32,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn map_window( &self, window: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn map_subwindows( &self, window: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn unmap_window(
&self,
window: u32,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn unmap_window( &self, window: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn unmap_subwindows( &self, window: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn configure_window<'c, 'input>(
&'c self,
window: u32,
value_list: &'input ConfigureWindowAux,
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn configure_window<'c, 'input>( &'c self, window: u32, value_list: &'input ConfigureWindowAux, ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn circulate_window(
&self,
direction: Circulate,
window: u32,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn circulate_window( &self, direction: Circulate, window: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn get_geometry(
&self,
drawable: u32,
) -> Result<Cookie<'_, Self, GetGeometryReply>, ConnectionError>
fn get_geometry( &self, drawable: u32, ) -> Result<Cookie<'_, Self, GetGeometryReply>, ConnectionError>
§fn query_tree(
&self,
window: u32,
) -> Result<Cookie<'_, Self, QueryTreeReply>, ConnectionError>
fn query_tree( &self, window: u32, ) -> Result<Cookie<'_, Self, QueryTreeReply>, ConnectionError>
§fn intern_atom<'c, 'input>(
&'c self,
only_if_exists: bool,
name: &'input [u8],
) -> Result<Cookie<'c, Self, InternAtomReply>, ConnectionError>
fn intern_atom<'c, 'input>( &'c self, only_if_exists: bool, name: &'input [u8], ) -> Result<Cookie<'c, Self, InternAtomReply>, ConnectionError>
fn get_atom_name( &self, atom: u32, ) -> Result<Cookie<'_, Self, GetAtomNameReply>, ConnectionError>
§fn change_property<'c, 'input, A, B>(
&'c self,
mode: PropMode,
window: u32,
property: A,
type_: B,
format: u8,
data_len: u32,
data: &'input [u8],
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn change_property<'c, 'input, A, B>( &'c self, mode: PropMode, window: u32, property: A, type_: B, format: u8, data_len: u32, data: &'input [u8], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn delete_property( &self, window: u32, property: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn get_property<A, B>(
&self,
delete: bool,
window: u32,
property: A,
type_: B,
long_offset: u32,
long_length: u32,
) -> Result<Cookie<'_, Self, GetPropertyReply>, ConnectionError>
fn get_property<A, B>( &self, delete: bool, window: u32, property: A, type_: B, long_offset: u32, long_length: u32, ) -> Result<Cookie<'_, Self, GetPropertyReply>, ConnectionError>
fn list_properties( &self, window: u32, ) -> Result<Cookie<'_, Self, ListPropertiesReply>, ConnectionError>
§fn set_selection_owner<A, B>(
&self,
owner: A,
selection: u32,
time: B,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn set_selection_owner<A, B>( &self, owner: A, selection: u32, time: B, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn get_selection_owner(
&self,
selection: u32,
) -> Result<Cookie<'_, Self, GetSelectionOwnerReply>, ConnectionError>
fn get_selection_owner( &self, selection: u32, ) -> Result<Cookie<'_, Self, GetSelectionOwnerReply>, ConnectionError>
fn convert_selection<A, B>( &self, requestor: u32, selection: u32, target: u32, property: A, time: B, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn send_event<A, B>(
&self,
propagate: bool,
destination: A,
event_mask: EventMask,
event: B,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn send_event<A, B>( &self, propagate: bool, destination: A, event_mask: EventMask, event: B, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn grab_pointer<A, B, C>(
&self,
owner_events: bool,
grab_window: u32,
event_mask: EventMask,
pointer_mode: GrabMode,
keyboard_mode: GrabMode,
confine_to: A,
cursor: B,
time: C,
) -> Result<Cookie<'_, Self, GrabPointerReply>, ConnectionError>
fn grab_pointer<A, B, C>( &self, owner_events: bool, grab_window: u32, event_mask: EventMask, pointer_mode: GrabMode, keyboard_mode: GrabMode, confine_to: A, cursor: B, time: C, ) -> Result<Cookie<'_, Self, GrabPointerReply>, ConnectionError>
§fn ungrab_pointer<A>(
&self,
time: A,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn ungrab_pointer<A>( &self, time: A, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn change_active_pointer_grab<A, B>( &self, cursor: A, time: B, event_mask: EventMask, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn grab_keyboard<A>(
&self,
owner_events: bool,
grab_window: u32,
time: A,
pointer_mode: GrabMode,
keyboard_mode: GrabMode,
) -> Result<Cookie<'_, Self, GrabKeyboardReply>, ConnectionError>
fn grab_keyboard<A>( &self, owner_events: bool, grab_window: u32, time: A, pointer_mode: GrabMode, keyboard_mode: GrabMode, ) -> Result<Cookie<'_, Self, GrabKeyboardReply>, ConnectionError>
fn ungrab_keyboard<A>( &self, time: A, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn grab_key<A>(
&self,
owner_events: bool,
grab_window: u32,
modifiers: ModMask,
key: A,
pointer_mode: GrabMode,
keyboard_mode: GrabMode,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn grab_key<A>( &self, owner_events: bool, grab_window: u32, modifiers: ModMask, key: A, pointer_mode: GrabMode, keyboard_mode: GrabMode, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn ungrab_key<A>(
&self,
key: A,
grab_window: u32,
modifiers: ModMask,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn ungrab_key<A>( &self, key: A, grab_window: u32, modifiers: ModMask, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn allow_events<A>(
&self,
mode: Allow,
time: A,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn allow_events<A>( &self, mode: Allow, time: A, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn grab_server(&self) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn ungrab_server(&self) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn query_pointer(
&self,
window: u32,
) -> Result<Cookie<'_, Self, QueryPointerReply>, ConnectionError>
fn query_pointer( &self, window: u32, ) -> Result<Cookie<'_, Self, QueryPointerReply>, ConnectionError>
fn get_motion_events<A, B>( &self, window: u32, start: A, stop: B, ) -> Result<Cookie<'_, Self, GetMotionEventsReply>, ConnectionError>
fn translate_coordinates( &self, src_window: u32, dst_window: u32, src_x: i16, src_y: i16, ) -> Result<Cookie<'_, Self, TranslateCoordinatesReply>, ConnectionError>
§fn warp_pointer<A, B>(
&self,
src_window: A,
dst_window: B,
src_x: i16,
src_y: i16,
src_width: u16,
src_height: u16,
dst_x: i16,
dst_y: i16,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn warp_pointer<A, B>( &self, src_window: A, dst_window: B, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn set_input_focus<A, B>(
&self,
revert_to: InputFocus,
focus: A,
time: B,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn set_input_focus<A, B>( &self, revert_to: InputFocus, focus: A, time: B, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn get_input_focus( &self, ) -> Result<Cookie<'_, Self, GetInputFocusReply>, ConnectionError>
fn query_keymap( &self, ) -> Result<Cookie<'_, Self, QueryKeymapReply>, ConnectionError>
§fn open_font<'c, 'input>(
&'c self,
fid: u32,
name: &'input [u8],
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn open_font<'c, 'input>( &'c self, fid: u32, name: &'input [u8], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn close_font(&self, font: u32) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn query_font(
&self,
font: u32,
) -> Result<Cookie<'_, Self, QueryFontReply>, ConnectionError>
fn query_font( &self, font: u32, ) -> Result<Cookie<'_, Self, QueryFontReply>, ConnectionError>
§fn query_text_extents<'c, 'input>(
&'c self,
font: u32,
string: &'input [Char2b],
) -> Result<Cookie<'c, Self, QueryTextExtentsReply>, ConnectionError>
fn query_text_extents<'c, 'input>( &'c self, font: u32, string: &'input [Char2b], ) -> Result<Cookie<'c, Self, QueryTextExtentsReply>, ConnectionError>
§fn list_fonts<'c, 'input>(
&'c self,
max_names: u16,
pattern: &'input [u8],
) -> Result<Cookie<'c, Self, ListFontsReply>, ConnectionError>
fn list_fonts<'c, 'input>( &'c self, max_names: u16, pattern: &'input [u8], ) -> Result<Cookie<'c, Self, ListFontsReply>, ConnectionError>
§fn list_fonts_with_info<'c, 'input>(
&'c self,
max_names: u16,
pattern: &'input [u8],
) -> Result<ListFontsWithInfoCookie<'c, Self>, ConnectionError>
fn list_fonts_with_info<'c, 'input>( &'c self, max_names: u16, pattern: &'input [u8], ) -> Result<ListFontsWithInfoCookie<'c, Self>, ConnectionError>
fn set_font_path<'c, 'input>( &'c self, font: &'input [Str], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn get_font_path( &self, ) -> Result<Cookie<'_, Self, GetFontPathReply>, ConnectionError>
§fn create_pixmap(
&self,
depth: u8,
pid: u32,
drawable: u32,
width: u16,
height: u16,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn create_pixmap( &self, depth: u8, pid: u32, drawable: u32, width: u16, height: u16, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn free_pixmap(
&self,
pixmap: u32,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn free_pixmap( &self, pixmap: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn create_gc<'c, 'input>(
&'c self,
cid: u32,
drawable: u32,
value_list: &'input CreateGCAux,
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn create_gc<'c, 'input>( &'c self, cid: u32, drawable: u32, value_list: &'input CreateGCAux, ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn change_gc<'c, 'input>(
&'c self,
gc: u32,
value_list: &'input ChangeGCAux,
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn change_gc<'c, 'input>( &'c self, gc: u32, value_list: &'input ChangeGCAux, ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn copy_gc( &self, src_gc: u32, dst_gc: u32, value_mask: GC, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn set_dashes<'c, 'input>( &'c self, gc: u32, dash_offset: u16, dashes: &'input [u8], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn set_clip_rectangles<'c, 'input>( &'c self, ordering: ClipOrdering, gc: u32, clip_x_origin: i16, clip_y_origin: i16, rectangles: &'input [Rectangle], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn free_gc(&self, gc: u32) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn free_gc(&self, gc: u32) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn clear_area( &self, exposures: bool, window: u32, x: i16, y: i16, width: u16, height: u16, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn copy_area(
&self,
src_drawable: u32,
dst_drawable: u32,
gc: u32,
src_x: i16,
src_y: i16,
dst_x: i16,
dst_y: i16,
width: u16,
height: u16,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn copy_area( &self, src_drawable: u32, dst_drawable: u32, gc: u32, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn copy_plane( &self, src_drawable: u32, dst_drawable: u32, gc: u32, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn poly_point<'c, 'input>( &'c self, coordinate_mode: CoordMode, drawable: u32, gc: u32, points: &'input [Point], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn poly_line<'c, 'input>(
&'c self,
coordinate_mode: CoordMode,
drawable: u32,
gc: u32,
points: &'input [Point],
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn poly_line<'c, 'input>( &'c self, coordinate_mode: CoordMode, drawable: u32, gc: u32, points: &'input [Point], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn poly_segment<'c, 'input>(
&'c self,
drawable: u32,
gc: u32,
segments: &'input [Segment],
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn poly_segment<'c, 'input>( &'c self, drawable: u32, gc: u32, segments: &'input [Segment], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn poly_rectangle<'c, 'input>( &'c self, drawable: u32, gc: u32, rectangles: &'input [Rectangle], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn poly_arc<'c, 'input>( &'c self, drawable: u32, gc: u32, arcs: &'input [Arc], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn fill_poly<'c, 'input>( &'c self, drawable: u32, gc: u32, shape: PolyShape, coordinate_mode: CoordMode, points: &'input [Point], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn poly_fill_rectangle<'c, 'input>(
&'c self,
drawable: u32,
gc: u32,
rectangles: &'input [Rectangle],
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn poly_fill_rectangle<'c, 'input>( &'c self, drawable: u32, gc: u32, rectangles: &'input [Rectangle], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn poly_fill_arc<'c, 'input>( &'c self, drawable: u32, gc: u32, arcs: &'input [Arc], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn put_image<'c, 'input>( &'c self, format: ImageFormat, drawable: u32, gc: u32, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data: &'input [u8], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn get_image( &self, format: ImageFormat, drawable: u32, x: i16, y: i16, width: u16, height: u16, plane_mask: u32, ) -> Result<Cookie<'_, Self, GetImageReply>, ConnectionError>
fn poly_text8<'c, 'input>( &'c self, drawable: u32, gc: u32, x: i16, y: i16, items: &'input [u8], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn poly_text16<'c, 'input>( &'c self, drawable: u32, gc: u32, x: i16, y: i16, items: &'input [u8], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn image_text8<'c, 'input>(
&'c self,
drawable: u32,
gc: u32,
x: i16,
y: i16,
string: &'input [u8],
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn image_text8<'c, 'input>( &'c self, drawable: u32, gc: u32, x: i16, y: i16, string: &'input [u8], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
§fn image_text16<'c, 'input>(
&'c self,
drawable: u32,
gc: u32,
x: i16,
y: i16,
string: &'input [Char2b],
) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn image_text16<'c, 'input>( &'c self, drawable: u32, gc: u32, x: i16, y: i16, string: &'input [Char2b], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn create_colormap( &self, alloc: ColormapAlloc, mid: u32, window: u32, visual: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn free_colormap( &self, cmap: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn copy_colormap_and_free( &self, mid: u32, src_cmap: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn install_colormap( &self, cmap: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn uninstall_colormap( &self, cmap: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn list_installed_colormaps( &self, window: u32, ) -> Result<Cookie<'_, Self, ListInstalledColormapsReply>, ConnectionError>
§fn alloc_color(
&self,
cmap: u32,
red: u16,
green: u16,
blue: u16,
) -> Result<Cookie<'_, Self, AllocColorReply>, ConnectionError>
fn alloc_color( &self, cmap: u32, red: u16, green: u16, blue: u16, ) -> Result<Cookie<'_, Self, AllocColorReply>, ConnectionError>
fn alloc_named_color<'c, 'input>( &'c self, cmap: u32, name: &'input [u8], ) -> Result<Cookie<'c, Self, AllocNamedColorReply>, ConnectionError>
fn alloc_color_cells( &self, contiguous: bool, cmap: u32, colors: u16, planes: u16, ) -> Result<Cookie<'_, Self, AllocColorCellsReply>, ConnectionError>
fn alloc_color_planes( &self, contiguous: bool, cmap: u32, colors: u16, reds: u16, greens: u16, blues: u16, ) -> Result<Cookie<'_, Self, AllocColorPlanesReply>, ConnectionError>
fn free_colors<'c, 'input>( &'c self, cmap: u32, plane_mask: u32, pixels: &'input [u32], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn store_colors<'c, 'input>( &'c self, cmap: u32, items: &'input [Coloritem], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn store_named_color<'c, 'input>( &'c self, flags: ColorFlag, cmap: u32, pixel: u32, name: &'input [u8], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn query_colors<'c, 'input>( &'c self, cmap: u32, pixels: &'input [u32], ) -> Result<Cookie<'c, Self, QueryColorsReply>, ConnectionError>
fn lookup_color<'c, 'input>( &'c self, cmap: u32, name: &'input [u8], ) -> Result<Cookie<'c, Self, LookupColorReply>, ConnectionError>
fn create_cursor<A>( &self, cid: u32, source: u32, mask: A, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn create_glyph_cursor<A>(
&self,
cid: u32,
source_font: u32,
mask_font: A,
source_char: u16,
mask_char: u16,
fore_red: u16,
fore_green: u16,
fore_blue: u16,
back_red: u16,
back_green: u16,
back_blue: u16,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn create_glyph_cursor<A>( &self, cid: u32, source_font: u32, mask_font: A, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn free_cursor(
&self,
cursor: u32,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn free_cursor( &self, cursor: u32, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn recolor_cursor( &self, cursor: u32, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn query_best_size( &self, class: QueryShapeOf, drawable: u32, width: u16, height: u16, ) -> Result<Cookie<'_, Self, QueryBestSizeReply>, ConnectionError>
§fn query_extension<'c, 'input>(
&'c self,
name: &'input [u8],
) -> Result<Cookie<'c, Self, QueryExtensionReply>, ConnectionError>
fn query_extension<'c, 'input>( &'c self, name: &'input [u8], ) -> Result<Cookie<'c, Self, QueryExtensionReply>, ConnectionError>
fn list_extensions( &self, ) -> Result<Cookie<'_, Self, ListExtensionsReply>, ConnectionError>
fn change_keyboard_mapping<'c, 'input>( &'c self, keycode_count: u8, first_keycode: u8, keysyms_per_keycode: u8, keysyms: &'input [u32], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn get_keyboard_mapping( &self, first_keycode: u8, count: u8, ) -> Result<Cookie<'_, Self, GetKeyboardMappingReply>, ConnectionError>
fn change_keyboard_control<'c, 'input>( &'c self, value_list: &'input ChangeKeyboardControlAux, ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn get_keyboard_control( &self, ) -> Result<Cookie<'_, Self, GetKeyboardControlReply>, ConnectionError>
fn bell(&self, percent: i8) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn change_pointer_control( &self, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: bool, do_threshold: bool, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn get_pointer_control( &self, ) -> Result<Cookie<'_, Self, GetPointerControlReply>, ConnectionError>
fn set_screen_saver( &self, timeout: i16, interval: i16, prefer_blanking: Blanking, allow_exposures: Exposures, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn get_screen_saver( &self, ) -> Result<Cookie<'_, Self, GetScreenSaverReply>, ConnectionError>
fn change_hosts<'c, 'input>( &'c self, mode: HostMode, family: Family, address: &'input [u8], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn list_hosts( &self, ) -> Result<Cookie<'_, Self, ListHostsReply>, ConnectionError>
fn set_access_control( &self, mode: AccessControl, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn set_close_down_mode( &self, mode: CloseDown, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn kill_client<A>(
&self,
resource: A,
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn kill_client<A>( &self, resource: A, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn rotate_properties<'c, 'input>( &'c self, window: u32, delta: i16, atoms: &'input [u32], ) -> Result<VoidCookie<'c, Self>, ConnectionError>
fn force_screen_saver( &self, mode: ScreenSaver, ) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn set_pointer_mapping<'c, 'input>( &'c self, map: &'input [u8], ) -> Result<Cookie<'c, Self, SetPointerMappingReply>, ConnectionError>
fn get_pointer_mapping( &self, ) -> Result<Cookie<'_, Self, GetPointerMappingReply>, ConnectionError>
fn set_modifier_mapping<'c, 'input>( &'c self, keycodes: &'input [u8], ) -> Result<Cookie<'c, Self, SetModifierMappingReply>, ConnectionError>
fn get_modifier_mapping( &self, ) -> Result<Cookie<'_, Self, GetModifierMappingReply>, ConnectionError>
fn no_operation(&self) -> Result<VoidCookie<'_, Self>, ConnectionError>
§impl<C> ConnectionExt for Cwhere
C: RequestConnection + ?Sized,
impl<C> ConnectionExt for Cwhere
C: RequestConnection + ?Sized,
fn xc_misc_get_version( &self, client_major_version: u16, client_minor_version: u16, ) -> Result<Cookie<'_, Self, GetVersionReply>, ConnectionError>
fn xc_misc_get_xid_range( &self, ) -> Result<Cookie<'_, Self, GetXIDRangeReply>, ConnectionError>
fn xc_misc_get_xid_list( &self, count: u32, ) -> Result<Cookie<'_, Self, GetXIDListReply>, ConnectionError>
§impl<C> ConnectionExt for Cwhere
C: ConnectionExt + ?Sized,
impl<C> ConnectionExt for Cwhere
C: ConnectionExt + ?Sized,
§fn change_property8<A, B>(
&self,
mode: PropMode,
window: u32,
property: A,
type_: B,
data: &[u8],
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn change_property8<A, B>( &self, mode: PropMode, window: u32, property: A, type_: B, data: &[u8], ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn change_property16<A, B>(
&self,
mode: PropMode,
window: u32,
property: A,
type_: B,
data: &[u16],
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn change_property16<A, B>( &self, mode: PropMode, window: u32, property: A, type_: B, data: &[u16], ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§fn change_property32<A, B>(
&self,
mode: PropMode,
window: u32,
property: A,
type_: B,
data: &[u32],
) -> Result<VoidCookie<'_, Self>, ConnectionError>
fn change_property32<A, B>( &self, mode: PropMode, window: u32, property: A, type_: B, data: &[u32], ) -> Result<VoidCookie<'_, Self>, ConnectionError>
§impl<T> Conv for T
impl<T> Conv for T
§impl<F> CpuIdReader for F
impl<F> CpuIdReader for F
source§impl<T> CryptoRngCore for T
impl<T> CryptoRngCore for T
source§fn as_rngcore(&mut self) -> &mut dyn RngCore
fn as_rngcore(&mut self) -> &mut dyn RngCore
RngCore trait object.§impl<'a, T> Decode<'a> for Twhere
T: DecodeValue<'a> + FixedTag,
impl<'a, T> Decode<'a> for Twhere
T: DecodeValue<'a> + FixedTag,
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
further downcast into Rc<ConcreteType> where ConcreteType implements Trait.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.§impl<T> DowncastSync for T
impl<T> DowncastSync for T
§impl<T> DynEq for T
impl<T> DynEq for T
source§impl<N, E, I> ElementIterator<N, E> for I
impl<N, E, I> ElementIterator<N, E> for I
§impl<'e, I, E> EmitAndCount for I
impl<'e, I, E> EmitAndCount for I
§impl<T> Encode for Twhere
T: EncodeValue + Tagged,
impl<T> Encode for Twhere
T: EncodeValue + Tagged,
§fn encoded_len(&self) -> Result<Length, Error>
fn encoded_len(&self) -> Result<Length, Error>
Compute the length of this value in bytes when encoded as ASN.1 DER.
§fn encode(&self, writer: &mut impl Writer) -> Result<(), Error>
fn encode(&self, writer: &mut impl Writer) -> Result<(), Error>
Encode this value as ASN.1 DER using the provided [Writer].
§fn encode_to_slice<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8], Error>
fn encode_to_slice<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8], Error>
§fn encode_to_vec(&self, buf: &mut Vec<u8>) -> Result<Length, Error>
fn encode_to_vec(&self, buf: &mut Vec<u8>) -> Result<Length, Error>
§impl<F> EntityCommand for F
impl<F> EntityCommand for F
§fn with_entity(self, id: Entity) -> WithEntity<Self>where
Self: Sized,
fn with_entity(self, id: Entity) -> WithEntity<Self>where
Self: Sized,
Command] which executes this [EntityCommand] for the given [Entity].§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key and return true if they are equal.source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key and return true if they are equal.§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
fn equivalent(&self, key: &K) -> bool
§impl<F> EventHandler for F
impl<F> EventHandler for F
§fn handle_event(&mut self, event: Result<Event, Error>)
fn handle_event(&mut self, event: Result<Event, Error>)
§impl<Out, Func> ExclusiveSystemParamFunction<fn() -> Out> for Funcwhere
Func: Send + Sync + 'static,
&'a mut Func: for<'a> FnMut(&mut World) -> Out + for<'a> FnMut(&mut World),
Out: 'static,
impl<Out, Func> ExclusiveSystemParamFunction<fn() -> Out> for Funcwhere
Func: Send + Sync + 'static,
&'a mut Func: for<'a> FnMut(&mut World) -> Out + for<'a> FnMut(&mut World),
Out: 'static,
§impl<Out, Func, F0> ExclusiveSystemParamFunction<fn(_: F0) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0> ExclusiveSystemParamFunction<fn(_: F0) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§impl<Out, Func, F0, F1> ExclusiveSystemParamFunction<fn(_: F0, _: F1) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1> ExclusiveSystemParamFunction<fn(_: F0, _: F1) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§impl<Out, Func, F0, F1, F2> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2)
type Param = (F0, F1, F2)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3)
type Param = (F0, F1, F2, F3)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4)
type Param = (F0, F1, F2, F3, F4)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5)
type Param = (F0, F1, F2, F3, F4, F5)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6)
type Param = (F0, F1, F2, F3, F4, F5, F6)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
F14: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>, <F14 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
F14: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>, <F14 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14, _: F15) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
F14: ExclusiveSystemParam,
F15: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>, <F14 as ExclusiveSystemParam>::Item<'_>, <F15 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15> ExclusiveSystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14, _: F15) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
F14: ExclusiveSystemParam,
F15: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(&mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) -> Out + for<'a> FnMut(&mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>, <F14 as ExclusiveSystemParam>::Item<'_>, <F15 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
_in: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, _in: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func> ExclusiveSystemParamFunction<fn(_: In<Input>) -> Out> for Funcwhere
Func: Send + Sync + 'static,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World) -> Out + for<'a> FnMut(In<Input>, &mut World),
Out: 'static,
impl<Input, Out, Func> ExclusiveSystemParamFunction<fn(_: In<Input>) -> Out> for Funcwhere
Func: Send + Sync + 'static,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World) -> Out + for<'a> FnMut(In<Input>, &mut World),
Out: 'static,
§impl<Input, Out, Func, F0> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§impl<Input, Out, Func, F0, F1> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§impl<Input, Out, Func, F0, F1, F2> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2)
type Param = (F0, F1, F2)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3)
type Param = (F0, F1, F2, F3)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4)
type Param = (F0, F1, F2, F3, F4)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5)
type Param = (F0, F1, F2, F3, F4, F5)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6)
type Param = (F0, F1, F2, F3, F4, F5, F6)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
F14: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>, <F14 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
F14: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>, <F14 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14, _: F15) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
F14: ExclusiveSystemParam,
F15: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>, <F14 as ExclusiveSystemParam>::Item<'_>, <F15 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15> ExclusiveSystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14, _: F15) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: ExclusiveSystemParam,
F1: ExclusiveSystemParam,
F2: ExclusiveSystemParam,
F3: ExclusiveSystemParam,
F4: ExclusiveSystemParam,
F5: ExclusiveSystemParam,
F6: ExclusiveSystemParam,
F7: ExclusiveSystemParam,
F8: ExclusiveSystemParam,
F9: ExclusiveSystemParam,
F10: ExclusiveSystemParam,
F11: ExclusiveSystemParam,
F12: ExclusiveSystemParam,
F13: ExclusiveSystemParam,
F14: ExclusiveSystemParam,
F15: ExclusiveSystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, &mut World, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) -> Out + for<'a> FnMut(In<Input>, &mut World, <F0 as ExclusiveSystemParam>::Item<'_>, <F1 as ExclusiveSystemParam>::Item<'_>, <F2 as ExclusiveSystemParam>::Item<'_>, <F3 as ExclusiveSystemParam>::Item<'_>, <F4 as ExclusiveSystemParam>::Item<'_>, <F5 as ExclusiveSystemParam>::Item<'_>, <F6 as ExclusiveSystemParam>::Item<'_>, <F7 as ExclusiveSystemParam>::Item<'_>, <F8 as ExclusiveSystemParam>::Item<'_>, <F9 as ExclusiveSystemParam>::Item<'_>, <F10 as ExclusiveSystemParam>::Item<'_>, <F11 as ExclusiveSystemParam>::Item<'_>, <F12 as ExclusiveSystemParam>::Item<'_>, <F13 as ExclusiveSystemParam>::Item<'_>, <F14 as ExclusiveSystemParam>::Item<'_>, <F15 as ExclusiveSystemParam>::Item<'_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
ExclusiveSystemParam]/s defined by this system’s fn parameters.§fn run(
&mut self,
world: &mut World,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) as ExclusiveSystemParam>::Item<'_>,
) -> Out
fn run( &mut self, world: &mut World, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) as ExclusiveSystemParam>::Item<'_>, ) -> Out
System::run].§impl<F, OutputVertex> FillVertexConstructor<OutputVertex> for Fwhere
F: Fn(FillVertex<'_>) -> OutputVertex,
impl<F, OutputVertex> FillVertexConstructor<OutputVertex> for Fwhere
F: Fn(FillVertex<'_>) -> OutputVertex,
fn new_vertex(&mut self, vertex: FillVertex<'_>) -> OutputVertex
source§impl<F, N> FilterEdge<N> for F
impl<F, N> FilterEdge<N> for F
source§fn include_edge(&self, n: N) -> bool
fn include_edge(&self, n: N) -> bool
§impl<F, S> FilterExt<S> for Fwhere
F: Filter<S>,
impl<F, S> FilterExt<S> for Fwhere
F: Filter<S>,
§impl<F> FilterFn for F
impl<F> FilterFn for F
source§impl<F, N> FilterNode<N> for F
impl<F, N> FilterNode<N> for F
source§fn include_node(&self, n: N) -> bool
fn include_node(&self, n: N) -> bool
§impl<E, S, T> FirstAnswer<T, E> for S
impl<E, S, T> FirstAnswer<T, E> for S
§fn first_answer(self) -> FirstAnswerFuture<Self> ⓘ
fn first_answer(self) -> FirstAnswerFuture<Self> ⓘ
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self to use its Binary implementation when Debug-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self to use its Display implementation when
Debug-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self to use its LowerExp implementation when
Debug-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self to use its LowerHex implementation when
Debug-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self to use its Octal implementation when Debug-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self to use its Pointer implementation when
Debug-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self to use its UpperExp implementation when
Debug-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self to use its UpperHex implementation when
Debug-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<S> FromSample<S> for S
impl<S> FromSample<S> for S
fn from_sample_(s: S) -> S
§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
§fn from_world(_world: &mut World) -> T
fn from_world(_world: &mut World) -> T
Self using data from the given [World]§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
§fn from_world(_world: &World) -> T
fn from_world(_world: &World) -> T
Self using data from the given World.§impl<F> FutureExt for F
impl<F> FutureExt for F
§fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere
Self: Sized + UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere
Self: Sized + UnwindSafe,
§impl<F> FutureExt for F
impl<F> FutureExt for F
§fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere
Self: Sized + UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere
Self: Sized + UnwindSafe,
§impl<F1> FutureExt for F1where
F1: Future,
impl<F1> FutureExt for F1where
F1: Future,
§fn join<F2>(self, other: F2) -> Join2<F1, <F2 as IntoFuture>::IntoFuture>where
F1: Future,
F2: IntoFuture,
fn join<F2>(self, other: F2) -> Join2<F1, <F2 as IntoFuture>::IntoFuture>where
F1: Future,
F2: IntoFuture,
§fn race<T, S2>(self, other: S2) -> Race2<T, F1, <S2 as IntoFuture>::IntoFuture>where
F1: Future<Output = T>,
S2: IntoFuture<Output = T>,
fn race<T, S2>(self, other: S2) -> Race2<T, F1, <S2 as IntoFuture>::IntoFuture>where
F1: Future<Output = T>,
S2: IntoFuture<Output = T>,
§fn wait_until<D>(
self,
deadline: D,
) -> WaitUntil<Self, <D as IntoFuture>::IntoFuture> ⓘwhere
Self: Sized,
D: IntoFuture,
fn wait_until<D>(
self,
deadline: D,
) -> WaitUntil<Self, <D as IntoFuture>::IntoFuture> ⓘwhere
Self: Sized,
D: IntoFuture,
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn map<U, F>(self, f: F) -> Map<Self, F> ⓘ
fn map<U, F>(self, f: F) -> Map<Self, F> ⓘ
§fn map_into<U>(self) -> MapInto<Self, U> ⓘ
fn map_into<U>(self) -> MapInto<Self, U> ⓘ
§fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> ⓘ
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> ⓘ
f. Read more§fn left_future<B>(self) -> Either<Self, B> ⓘ
fn left_future<B>(self) -> Either<Self, B> ⓘ
§fn right_future<A>(self) -> Either<A, Self> ⓘ
fn right_future<A>(self) -> Either<A, Self> ⓘ
§fn into_stream(self) -> IntoStream<Self>where
Self: Sized,
fn into_stream(self) -> IntoStream<Self>where
Self: Sized,
§fn flatten(self) -> Flatten<Self> ⓘ
fn flatten(self) -> Flatten<Self> ⓘ
§fn flatten_stream(self) -> FlattenStream<Self>
fn flatten_stream(self) -> FlattenStream<Self>
§fn fuse(self) -> Fuse<Self> ⓘwhere
Self: Sized,
fn fuse(self) -> Fuse<Self> ⓘwhere
Self: Sized,
poll will never again be called once it has
completed. This method can be used to turn any Future into a
FusedFuture. Read more§fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘ
fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘ
§fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere
Self: Sized + UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self> ⓘwhere
Self: Sized + UnwindSafe,
§fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)where
Self: Sized,
fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)where
Self: Sized,
() on completion and sends
its output to another future on a separate task. Read more§fn boxed<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a>>
fn boxed<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a>>
§fn boxed_local<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>>where
Self: Sized + 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>>where
Self: Sized + 'a,
§fn unit_error(self) -> UnitError<Self> ⓘwhere
Self: Sized,
fn unit_error(self) -> UnitError<Self> ⓘwhere
Self: Sized,
Future<Output = T> into a
TryFuture<Ok = T, Error = ()>.§fn never_error(self) -> NeverError<Self> ⓘwhere
Self: Sized,
fn never_error(self) -> NeverError<Self> ⓘwhere
Self: Sized,
Future<Output = T> into a
TryFuture<Ok = T, Error = Never>.§impl<F> GamePlugin for F
impl<F> GamePlugin for F
§impl<T, B1, B2> HttpService<B1> for T
impl<T, B1, B2> HttpService<B1> for T
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
source§impl<I> IntoAsyncIterator for Iwhere
I: AsyncIterator,
impl<I> IntoAsyncIterator for Iwhere
I: AsyncIterator,
§type Item = <I as AsyncIterator>::Item
type Item = <I as AsyncIterator>::Item
async_iterator)§type IntoAsyncIter = I
type IntoAsyncIter = I
async_iterator)source§fn into_async_iter(self) -> <I as IntoAsyncIterator>::IntoAsyncIter
fn into_async_iter(self) -> <I as IntoAsyncIterator>::IntoAsyncIter
async_iterator)self into an async iteratorsource§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moresource§impl<I> IntoFallibleIterator for Iwhere
I: FallibleIterator,
impl<I> IntoFallibleIterator for Iwhere
I: FallibleIterator,
§type Item = <I as FallibleIterator>::Item
type Item = <I as FallibleIterator>::Item
§type Error = <I as FallibleIterator>::Error
type Error = <I as FallibleIterator>::Error
§type IntoFallibleIter = I
type IntoFallibleIter = I
source§fn into_fallible_iter(self) -> I
fn into_fallible_iter(self) -> I
source§impl<F> IntoFuture for Fwhere
F: Future,
impl<F> IntoFuture for Fwhere
F: Future,
§type IntoFuture = F
type IntoFuture = F
source§fn into_future(self) -> <F as IntoFuture>::IntoFuture
fn into_future(self) -> <F as IntoFuture>::IntoFuture
source§impl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere
I: Iterator,
§impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
fn into_sample(self) -> T
§impl<S> IntoStream for Swhere
S: Stream,
impl<S> IntoStream for Swhere
S: Stream,
§type IntoStream = S
type IntoStream = S
§fn into_stream(self) -> S
fn into_stream(self) -> S
§impl<Marker, F> IntoSystem<<F as ExclusiveSystemParamFunction<Marker>>::In, <F as ExclusiveSystemParamFunction<Marker>>::Out, (IsExclusiveFunctionSystem, Marker)> for Fwhere
Marker: 'static,
F: ExclusiveSystemParamFunction<Marker>,
impl<Marker, F> IntoSystem<<F as ExclusiveSystemParamFunction<Marker>>::In, <F as ExclusiveSystemParamFunction<Marker>>::Out, (IsExclusiveFunctionSystem, Marker)> for Fwhere
Marker: 'static,
F: ExclusiveSystemParamFunction<Marker>,
§type System = ExclusiveFunctionSystem<Marker, F>
type System = ExclusiveFunctionSystem<Marker, F>
System] that this instance converts into.§fn into_system(
func: F,
) -> <F as IntoSystem<<F as ExclusiveSystemParamFunction<Marker>>::In, <F as ExclusiveSystemParamFunction<Marker>>::Out, (IsExclusiveFunctionSystem, Marker)>>::System
fn into_system( func: F, ) -> <F as IntoSystem<<F as ExclusiveSystemParamFunction<Marker>>::In, <F as ExclusiveSystemParamFunction<Marker>>::Out, (IsExclusiveFunctionSystem, Marker)>>::System
System].§impl<Marker, F> IntoSystem<<F as SystemParamFunction<Marker>>::In, <F as SystemParamFunction<Marker>>::Out, (IsFunctionSystem, Marker)> for Fwhere
Marker: 'static,
F: SystemParamFunction<Marker>,
impl<Marker, F> IntoSystem<<F as SystemParamFunction<Marker>>::In, <F as SystemParamFunction<Marker>>::Out, (IsFunctionSystem, Marker)> for Fwhere
Marker: 'static,
F: SystemParamFunction<Marker>,
§fn into_system(
func: F,
) -> <F as IntoSystem<<F as SystemParamFunction<Marker>>::In, <F as SystemParamFunction<Marker>>::Out, (IsFunctionSystem, Marker)>>::System
fn into_system( func: F, ) -> <F as IntoSystem<<F as SystemParamFunction<Marker>>::In, <F as SystemParamFunction<Marker>>::Out, (IsFunctionSystem, Marker)>>::System
System].§impl<F, Out> IntoSystem<(F,), (), Out> for F
impl<F, Out> IntoSystem<(F,), (), Out> for F
§impl<F, Out, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
A: SystemParam,
B: SystemParam,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<A as SystemParam>::Param<'a>, <B as SystemParam>::Param<'a>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
A: SystemParam,
B: SystemParam,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<A as SystemParam>::Param<'a>, <B as SystemParam>::Param<'a>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
B: SystemParam,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<B as SystemParam>::Param<'a>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
B: SystemParam,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<B as SystemParam>::Param<'a>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<'input, F, InT, Out> IntoSystem<(F, InT), InT, Out> for F
impl<'input, F, InT, Out> IntoSystem<(F, InT), InT, Out> for F
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§impl<'input, F, InT, Out, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
A: SystemParam,
B: SystemParam,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <A as SystemParam>::Param<'a>, <B as SystemParam>::Param<'a>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
A: SystemParam,
B: SystemParam,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <A as SystemParam>::Param<'a>, <B as SystemParam>::Param<'a>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
B: SystemParam,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <B as SystemParam>::Param<'a>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
B: SystemParam,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <B as SystemParam>::Param<'a>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
C: SystemParam,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <C as SystemParam>::Param<'a>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
D: SystemParam,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <D as SystemParam>::Param<'a>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
E: SystemParam,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <E as SystemParam>::Param<'a>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
G: SystemParam,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <G as SystemParam>::Param<'a>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
H: SystemParam,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <H as SystemParam>::Param<'a>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
I: SystemParam,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <I as SystemParam>::Param<'a>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, O, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, P, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, Q, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, Q, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, Q, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, R, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, R, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, R, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, S, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, S, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, S, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, S, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, T, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, T, U, V, W, X, Y, Z> IntoSystem<(F, InT, T, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(
self,
) -> <F as IntoSystem<(F, InT, T, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, InT, T, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, U, V, W, X, Y, Z> IntoSystem<(F, InT, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, U, V, W, X, Y, Z),
impl<'input, F, InT, Out, U, V, W, X, Y, Z> IntoSystem<(F, InT, U, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, U, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(self) -> <F as IntoSystem<(F, InT, U, V, W, X, Y, Z), InT, Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, InT, U, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, V, W, X, Y, Z> IntoSystem<(F, InT, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, V, W, X, Y, Z),
impl<'input, F, InT, Out, V, W, X, Y, Z> IntoSystem<(F, InT, V, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, V, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(self) -> <F as IntoSystem<(F, InT, V, W, X, Y, Z), InT, Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, InT, V, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, W, X, Y, Z> IntoSystem<(F, InT, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, W, X, Y, Z),
impl<'input, F, InT, Out, W, X, Y, Z> IntoSystem<(F, InT, W, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, W, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(self) -> <F as IntoSystem<(F, InT, W, X, Y, Z), InT, Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, InT, W, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, X, Y, Z> IntoSystem<(F, InT, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, X, Y, Z),
impl<'input, F, InT, Out, X, Y, Z> IntoSystem<(F, InT, X, Y, Z), InT, Out> for Fwhere
InT: 'input,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, X, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(self) -> <F as IntoSystem<(F, InT, X, Y, Z), InT, Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, InT, X, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, Y, Z> IntoSystem<(F, InT, Y, Z), InT, Out> for Fwhere
InT: 'input,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, Y, Z),
impl<'input, F, InT, Out, Y, Z> IntoSystem<(F, InT, Y, Z), InT, Out> for Fwhere
InT: 'input,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, Y, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(self) -> <F as IntoSystem<(F, InT, Y, Z), InT, Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, InT, Y, Z), InT, Out>>::Sys
System.§impl<'input, F, InT, Out, Z> IntoSystem<(F, InT, Z), InT, Out> for Fwhere
InT: 'input,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, Z),
impl<'input, F, InT, Out, Z> IntoSystem<(F, InT, Z), InT, Out> for Fwhere
InT: 'input,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(In<InT>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(In<InT>, Z),
§type Sys = StaticSystem<InT, Out>
type Sys = StaticSystem<InT, Out>
§fn system(self) -> <F as IntoSystem<(F, InT, Z), InT, Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, InT, Z), InT, Out>>::Sys
System.§impl<F, Out, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
J: SystemParam,
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<J as SystemParam>::Param<'a>, <K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
K: SystemParam,
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<K as SystemParam>::Param<'a>, <L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
L: SystemParam,
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<L as SystemParam>::Param<'a>, <M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
M: SystemParam,
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<M as SystemParam>::Param<'a>, <N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
N: SystemParam,
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<N as SystemParam>::Param<'a>, <O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(N, O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(O, P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, O, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
O: SystemParam,
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<O as SystemParam>::Param<'a>, <P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(O, P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, O, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(P, Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, P, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
P: SystemParam,
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<P as SystemParam>::Param<'a>, <Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(P, Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, P, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(Q, R, S, T, U, V, W, X, Y, Z),
impl<F, Out, Q, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, Q, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
Q: SystemParam,
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<Q as SystemParam>::Param<'a>, <R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(Q, R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, Q, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(R, S, T, U, V, W, X, Y, Z),
impl<F, Out, R, S, T, U, V, W, X, Y, Z> IntoSystem<(F, R, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
R: SystemParam,
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<R as SystemParam>::Param<'a>, <S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(R, S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(
self,
) -> <F as IntoSystem<(F, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system( self, ) -> <F as IntoSystem<(F, R, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, S, T, U, V, W, X, Y, Z> IntoSystem<(F, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(S, T, U, V, W, X, Y, Z),
impl<F, Out, S, T, U, V, W, X, Y, Z> IntoSystem<(F, S, T, U, V, W, X, Y, Z), (), Out> for Fwhere
S: SystemParam,
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<S as SystemParam>::Param<'a>, <T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(S, T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(self) -> <F as IntoSystem<(F, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, S, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, T, U, V, W, X, Y, Z> IntoSystem<(F, T, U, V, W, X, Y, Z), (), Out> for Fwhere
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(T, U, V, W, X, Y, Z),
impl<F, Out, T, U, V, W, X, Y, Z> IntoSystem<(F, T, U, V, W, X, Y, Z), (), Out> for Fwhere
T: SystemParam,
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<T as SystemParam>::Param<'a>, <U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(T, U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(self) -> <F as IntoSystem<(F, T, U, V, W, X, Y, Z), (), Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, T, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, U, V, W, X, Y, Z> IntoSystem<(F, U, V, W, X, Y, Z), (), Out> for Fwhere
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(U, V, W, X, Y, Z),
impl<F, Out, U, V, W, X, Y, Z> IntoSystem<(F, U, V, W, X, Y, Z), (), Out> for Fwhere
U: SystemParam,
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<U as SystemParam>::Param<'a>, <V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(U, V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(self) -> <F as IntoSystem<(F, U, V, W, X, Y, Z), (), Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, U, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, V, W, X, Y, Z> IntoSystem<(F, V, W, X, Y, Z), (), Out> for Fwhere
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(V, W, X, Y, Z),
impl<F, Out, V, W, X, Y, Z> IntoSystem<(F, V, W, X, Y, Z), (), Out> for Fwhere
V: SystemParam,
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<V as SystemParam>::Param<'a>, <W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(V, W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(self) -> <F as IntoSystem<(F, V, W, X, Y, Z), (), Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, V, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, W, X, Y, Z> IntoSystem<(F, W, X, Y, Z), (), Out> for Fwhere
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(W, X, Y, Z),
impl<F, Out, W, X, Y, Z> IntoSystem<(F, W, X, Y, Z), (), Out> for Fwhere
W: SystemParam,
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<W as SystemParam>::Param<'a>, <X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(W, X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(self) -> <F as IntoSystem<(F, W, X, Y, Z), (), Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, W, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, X, Y, Z> IntoSystem<(F, X, Y, Z), (), Out> for Fwhere
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(X, Y, Z),
impl<F, Out, X, Y, Z> IntoSystem<(F, X, Y, Z), (), Out> for Fwhere
X: SystemParam,
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<X as SystemParam>::Param<'a>, <Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(X, Y, Z),
§type Sys = StaticSystem<(), Out>
type Sys = StaticSystem<(), Out>
§fn system(self) -> <F as IntoSystem<(F, X, Y, Z), (), Out>>::Sys
fn system(self) -> <F as IntoSystem<(F, X, Y, Z), (), Out>>::Sys
System.§impl<F, Out, Y, Z> IntoSystem<(F, Y, Z), (), Out> for Fwhere
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(Y, Z),
impl<F, Out, Y, Z> IntoSystem<(F, Y, Z), (), Out> for Fwhere
Y: SystemParam,
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<Y as SystemParam>::Param<'a>, <Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(Y, Z),
§impl<F, Out, Z> IntoSystem<(F, Z), (), Out> for Fwhere
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(Z),
impl<F, Out, Z> IntoSystem<(F, Z), (), Out> for Fwhere
Z: SystemParam,
F: 'static + for<'a> Send + for<'a> Sync + for<'a> FnMut(<Z as SystemParam>::Param<'a>) -> Out + for<'a> FnMut(Z),
§impl<Marker, F> IntoSystemConfigs<Marker> for F
impl<Marker, F> IntoSystemConfigs<Marker> for F
fn into_configs(self) -> SystemConfigs
§fn distributive_run_if<M>(
self,
condition: impl Condition<M> + Clone,
) -> SystemConfigs
fn distributive_run_if<M>( self, condition: impl Condition<M> + Clone, ) -> SystemConfigs
§fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs
fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> SystemConfigs
set.§fn ambiguous_with_all(self) -> SystemConfigs
fn ambiguous_with_all(self) -> SystemConfigs
§fn on_startup(self) -> SystemConfigs
fn on_startup(self) -> SystemConfigs
app.add_system(foo.on_startup()) has been deprecated in favor of app.add_systems(Startup, foo). Please migrate to that API.CoreSchedule::Startup.
This was a shorthand for self.in_schedule(CoreSchedule::Startup). Read more§fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemConfigs
fn in_schedule(self, _schedule: impl ScheduleLabel) -> SystemConfigs
app.add_system(foo.in_schedule(SomeSchedule)) has been deprecated in favor of app.add_systems(SomeSchedule, foo). Please migrate to that API.schedule. Read more§impl<Marker, F> IntoSystemSet<(IsExclusiveFunctionSystem, Marker)> for Fwhere
F: ExclusiveSystemParamFunction<Marker>,
impl<Marker, F> IntoSystemSet<(IsExclusiveFunctionSystem, Marker)> for Fwhere
F: ExclusiveSystemParamFunction<Marker>,
§fn into_system_set(
self,
) -> <F as IntoSystemSet<(IsExclusiveFunctionSystem, Marker)>>::Set
fn into_system_set( self, ) -> <F as IntoSystemSet<(IsExclusiveFunctionSystem, Marker)>>::Set
SystemSet] type.§impl<Marker, F> IntoSystemSet<(IsFunctionSystem, Marker)> for Fwhere
F: SystemParamFunction<Marker>,
impl<Marker, F> IntoSystemSet<(IsFunctionSystem, Marker)> for Fwhere
F: SystemParamFunction<Marker>,
§fn into_system_set(
self,
) -> <F as IntoSystemSet<(IsFunctionSystem, Marker)>>::Set
fn into_system_set( self, ) -> <F as IntoSystemSet<(IsFunctionSystem, Marker)>>::Set
SystemSet] type.source§impl<I> IteratorExt for Iwhere
I: Iterator,
impl<I> IteratorExt for Iwhere
I: Iterator,
source§fn transpose_into_fallible<T, E>(self) -> Convert<I>
fn transpose_into_fallible<T, E>(self) -> Convert<I>
Convert an iterator of Results into FallibleIterator by transposition
source§fn into_fallible<T>(self) -> IntoFallible<I>where
I: Iterator<Item = T>,
fn into_fallible<T>(self) -> IntoFallible<I>where
I: Iterator<Item = T>,
Convert an iterator of anything into FallibleIterator by wrapping
into Result<T, Infallible> where Infallible is an error that can never actually
happen.
source§impl<I> IteratorRandom for Iwhere
I: Iterator,
impl<I> IteratorRandom for Iwhere
I: Iterator,
source§fn choose<R>(self, rng: &mut R) -> Option<Self::Item>
fn choose<R>(self, rng: &mut R) -> Option<Self::Item>
source§fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>
fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>
source§impl<T> Itertools for T
impl<T> Itertools for T
source§fn interleave<J>(
self,
other: J,
) -> Interleave<Self, <J as IntoIterator>::IntoIter>
fn interleave<J>( self, other: J, ) -> Interleave<Self, <J as IntoIterator>::IntoIter>
source§fn interleave_shortest<J>(
self,
other: J,
) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>
fn interleave_shortest<J>( self, other: J, ) -> InterleaveShortest<Self, <J as IntoIterator>::IntoIter>
source§fn intersperse(
self,
element: Self::Item,
) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>
fn intersperse( self, element: Self::Item, ) -> IntersperseWith<Self, IntersperseElementSimple<Self::Item>>
source§fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>
fn intersperse_with<F>(self, element: F) -> IntersperseWith<Self, F>
source§fn zip_longest<J>(
self,
other: J,
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_longest<J>(
self,
other: J,
) -> ZipLongest<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
source§fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
fn zip_eq<J>(self, other: J) -> ZipEq<Self, <J as IntoIterator>::IntoIter>where
J: IntoIterator,
Self: Sized,
source§fn batching<B, F>(self, f: F) -> Batching<Self, F>
fn batching<B, F>(self, f: F) -> Batching<Self, F>
source§fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>
fn group_by<K, F>(self, key: F) -> GroupBy<K, Self, F>
source§fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
fn chunks(self, size: usize) -> IntoChunks<Self>where
Self: Sized,
source§fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
fn tuple_windows<T>(self) -> TupleWindows<Self, T>where
Self: Sized + Iterator<Item = <T as TupleCollect>::Item>,
T: HomogeneousTuple,
<T as TupleCollect>::Item: Clone,
source§fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>where
Self: Sized + Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone,
fn circular_tuple_windows<T>(self) -> CircularTupleWindows<Self, T>where
Self: Sized + Clone + Iterator<Item = <T as TupleCollect>::Item> + ExactSizeIterator,
T: TupleCollect + Clone,
<T as TupleCollect>::Item: Clone,
source§fn tuples<T>(self) -> Tuples<Self, T>
fn tuples<T>(self) -> Tuples<Self, T>
source§fn tee(self) -> (Tee<Self>, Tee<Self>)
fn tee(self) -> (Tee<Self>, Tee<Self>)
source§fn step(self, n: usize) -> Step<Self>where
Self: Sized,
fn step(self, n: usize) -> Step<Self>where
Self: Sized,
n elements in the base iterator
for each iteration. Read moresource§fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>
fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>
source§fn map_results<F, T, U, E>(
self,
f: F,
) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
fn map_results<F, T, U, E>( self, f: F, ) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
.map_ok().source§fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
fn map_ok<F, T, U, E>(self, f: F) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
Result::Ok value. Result::Err values are
unchanged. Read moresource§fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>
fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>
Result::Ok
value with the provided closure. Result::Err values are
unchanged. Read moresource§fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>
fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>
Result::Ok value with the provided closure. Result::Err
values are unchanged. Read moresource§fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>
fn flatten_ok<T, E>(self) -> FlattenOk<Self, T, E>
Result::Ok value into
a series of Result::Ok values. Result::Err values are unchanged. Read moresource§fn merge<J>(
self,
other: J,
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>
fn merge<J>( self, other: J, ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, MergeLte>
source§fn merge_by<J, F>(
self,
other: J,
is_first: F,
) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>
fn merge_by<J, F>( self, other: J, is_first: F, ) -> MergeBy<Self, <J as IntoIterator>::IntoIter, F>
source§fn merge_join_by<J, F>(
self,
other: J,
cmp_fn: F,
) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>
fn merge_join_by<J, F>( self, other: J, cmp_fn: F, ) -> MergeJoinBy<Self, <J as IntoIterator>::IntoIter, F>
source§fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>
fn kmerge(self) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, KMergeByLt>
source§fn kmerge_by<F>(
self,
first: F,
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
fn kmerge_by<F>(
self,
first: F,
) -> KMergeBy<<Self::Item as IntoIterator>::IntoIter, F>where
Self: Sized,
Self::Item: IntoIterator,
F: FnMut(&<Self::Item as IntoIterator>::Item, &<Self::Item as IntoIterator>::Item) -> bool,
source§fn cartesian_product<J>(
self,
other: J,
) -> Product<Self, <J as IntoIterator>::IntoIter>
fn cartesian_product<J>( self, other: J, ) -> Product<Self, <J as IntoIterator>::IntoIter>
self and J. Read moresource§fn multi_cartesian_product(
self,
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
fn multi_cartesian_product(
self,
) -> MultiProduct<<Self::Item as IntoIterator>::IntoIter>where
Self: Sized,
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::IntoIter: Clone,
<Self::Item as IntoIterator>::Item: Clone,
self. Read moresource§fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>
fn coalesce<F>(self, f: F) -> CoalesceBy<Self, F, Self::Item>
source§fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>
fn dedup(self) -> CoalesceBy<Self, DedupPred2CoalescePred<DedupEq>, Self::Item>
source§fn dedup_by<Cmp>(
self,
cmp: Cmp,
) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>
fn dedup_by<Cmp>( self, cmp: Cmp, ) -> CoalesceBy<Self, DedupPred2CoalescePred<Cmp>, Self::Item>
source§fn dedup_with_count(
self,
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where
Self: Sized,
fn dedup_with_count(
self,
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<DedupEq>, (usize, Self::Item)>where
Self: Sized,
source§fn dedup_by_with_count<Cmp>(
self,
cmp: Cmp,
) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>
fn dedup_by_with_count<Cmp>( self, cmp: Cmp, ) -> CoalesceBy<Self, DedupPredWithCount2CoalescePred<Cmp>, (usize, Self::Item)>
source§fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>
fn duplicates(self) -> DuplicatesBy<Self, Self::Item, ById>
source§fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>
fn duplicates_by<V, F>(self, f: F) -> DuplicatesBy<Self, V, ByFn<F>>
source§fn unique(self) -> Unique<Self>
fn unique(self) -> Unique<Self>
source§fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>
fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F>
source§fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>
fn peeking_take_while<F>(&mut self, accept: F) -> PeekingTakeWhile<'_, Self, F>
accept returns true. Read moresource§fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>
fn take_while_ref<F>(&mut self, accept: F) -> TakeWhileRef<'_, Self, F>
Clone-able iterator
to only pick off elements while the predicate accept returns true. Read moresource§fn while_some<A>(self) -> WhileSome<Self>
fn while_some<A>(self) -> WhileSome<Self>
Option<A> iterator elements
and produces A. Stops on the first None encountered. Read moresource§fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>
fn tuple_combinations<T>(self) -> TupleCombinations<Self, T>
source§fn combinations(self, k: usize) -> Combinations<Self>
fn combinations(self, k: usize) -> Combinations<Self>
k-length combinations of
the elements from an iterator. Read moresource§fn combinations_with_replacement(
self,
k: usize,
) -> CombinationsWithReplacement<Self>
fn combinations_with_replacement( self, k: usize, ) -> CombinationsWithReplacement<Self>
k-length combinations of
the elements from an iterator, with replacement. Read moresource§fn permutations(self, k: usize) -> Permutations<Self>
fn permutations(self, k: usize) -> Permutations<Self>
source§fn powerset(self) -> Powerset<Self>
fn powerset(self) -> Powerset<Self>
source§fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>
fn pad_using<F>(self, min: usize, f: F) -> PadUsing<Self, F>
min by filling missing elements using a closure f. Read moresource§fn with_position(self) -> WithPosition<Self>where
Self: Sized,
fn with_position(self) -> WithPosition<Self>where
Self: Sized,
Position to
ease special-case handling of the first or last elements. Read moresource§fn positions<P>(self, predicate: P) -> Positions<Self, P>
fn positions<P>(self, predicate: P) -> Positions<Self, P>
source§fn update<F>(self, updater: F) -> Update<Self, F>
fn update<F>(self, updater: F) -> Update<Self, F>
source§fn next_tuple<T>(&mut self) -> Option<T>
fn next_tuple<T>(&mut self) -> Option<T>
source§fn collect_tuple<T>(self) -> Option<T>
fn collect_tuple<T>(self) -> Option<T>
source§fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>
fn find_position<P>(&mut self, pred: P) -> Option<(usize, Self::Item)>
source§fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>
fn find_or_last<P>(self, predicate: P) -> Option<Self::Item>
source§fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>
fn find_or_first<P>(self, predicate: P) -> Option<Self::Item>
source§fn contains<Q>(&mut self, query: &Q) -> bool
fn contains<Q>(&mut self, query: &Q) -> bool
true if the given item is present in this iterator. Read moresource§fn all_unique(&mut self) -> bool
fn all_unique(&mut self) -> bool
source§fn dropping(self, n: usize) -> Selfwhere
Self: Sized,
fn dropping(self, n: usize) -> Selfwhere
Self: Sized,
n elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
fn dropping_back(self, n: usize) -> Selfwhere
Self: Sized + DoubleEndedIterator,
n elements from the iterator eagerly,
and return the same iterator again. Read moresource§fn foreach<F>(self, f: F)
fn foreach<F>(self, f: F)
f eagerly on each element of the iterator. Read moresource§fn collect_vec(self) -> Vec<Self::Item>where
Self: Sized,
fn collect_vec(self) -> Vec<Self::Item>where
Self: Sized,
.collect_vec() is simply a type specialization of Iterator::collect,
for convenience.source§fn try_collect<T, U, E>(self) -> Result<U, E>
fn try_collect<T, U, E>(self) -> Result<U, E>
source§fn set_from<'a, A, J>(&mut self, from: J) -> usize
fn set_from<'a, A, J>(&mut self, from: J) -> usize
self from the from iterator,
stopping at the shortest of the two iterators. Read moresource§fn join(&mut self, sep: &str) -> String
fn join(&mut self, sep: &str) -> String
sep. Read moresource§fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
fn format(self, sep: &str) -> Format<'_, Self>where
Self: Sized,
sep. Read moresource§fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>
fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>
sep. Read moresource§fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
.fold_ok().source§fn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
fn fold_ok<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
Result values from an iterator. Read moresource§fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>
fn fold_options<A, B, F>(&mut self, start: B, f: F) -> Option<B>
Option values from an iterator. Read moresource§fn fold1<F>(self, f: F) -> Option<Self::Item>
fn fold1<F>(self, f: F) -> Option<Self::Item>
Iterator::reduce insteadsource§fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
source§fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>
fn fold_while<B, F>(&mut self, init: B, f: F) -> FoldWhile<B>
source§fn sum1<S>(self) -> Option<S>
fn sum1<S>(self) -> Option<S>
source§fn product1<P>(self) -> Option<P>
fn product1<P>(self) -> Option<P>
source§fn sorted_unstable(self) -> IntoIter<Self::Item> ⓘ
fn sorted_unstable(self) -> IntoIter<Self::Item> ⓘ
source§fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
fn sorted_unstable_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
source§fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
fn sorted_unstable_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
source§fn sorted(self) -> IntoIter<Self::Item> ⓘ
fn sorted(self) -> IntoIter<Self::Item> ⓘ
source§fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
fn sorted_by<F>(self, cmp: F) -> IntoIter<Self::Item> ⓘ
source§fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
fn sorted_by_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
source§fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
fn sorted_by_cached_key<K, F>(self, f: F) -> IntoIter<Self::Item> ⓘ
source§fn k_smallest(self, k: usize) -> IntoIter<Self::Item> ⓘ
fn k_smallest(self, k: usize) -> IntoIter<Self::Item> ⓘ
source§fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)
fn partition_map<A, B, F, L, R>(self, predicate: F) -> (A, B)
Iterator::partition, each partition may
have a distinct type. Read moresource§fn partition_result<A, B, T, E>(self) -> (A, B)
fn partition_result<A, B, T, E>(self) -> (A, B)
Results into one list of all the Ok elements
and another list of all the Err elements. Read moresource§fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>>
fn into_group_map<K, V>(self) -> HashMap<K, Vec<V>>
HashMap of keys mapped to Vecs of values. Keys and values
are taken from (Key, Value) tuple pairs yielded by the input iterator. Read moresource§fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>
fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>
Iterator on a HashMap. Keys mapped to Vecs of values. The key is specified
in the closure. Read moresource§fn into_grouping_map<K, V>(self) -> GroupingMap<Self>
fn into_grouping_map<K, V>(self) -> GroupingMap<Self>
GroupingMap to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresource§fn into_grouping_map_by<K, V, F>(
self,
key_mapper: F,
) -> GroupingMap<MapForGrouping<Self, F>>
fn into_grouping_map_by<K, V, F>( self, key_mapper: F, ) -> GroupingMap<MapForGrouping<Self, F>>
GroupingMap to be used later with one of the efficient
group-and-fold operations it allows to perform. Read moresource§fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>
fn min_set_by<F>(self, compare: F) -> Vec<Self::Item>
source§fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
source§fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>
fn max_set_by<F>(self, compare: F) -> Vec<Self::Item>
source§fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
source§fn minmax(self) -> MinMaxResult<Self::Item>
fn minmax(self) -> MinMaxResult<Self::Item>
source§fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>
fn minmax_by_key<K, F>(self, key: F) -> MinMaxResult<Self::Item>
source§fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>
fn minmax_by<F>(self, compare: F) -> MinMaxResult<Self::Item>
source§fn position_max(self) -> Option<usize>
fn position_max(self) -> Option<usize>
source§fn position_max_by_key<K, F>(self, key: F) -> Option<usize>
fn position_max_by_key<K, F>(self, key: F) -> Option<usize>
source§fn position_max_by<F>(self, compare: F) -> Option<usize>
fn position_max_by<F>(self, compare: F) -> Option<usize>
source§fn position_min(self) -> Option<usize>
fn position_min(self) -> Option<usize>
source§fn position_min_by_key<K, F>(self, key: F) -> Option<usize>
fn position_min_by_key<K, F>(self, key: F) -> Option<usize>
source§fn position_min_by<F>(self, compare: F) -> Option<usize>
fn position_min_by<F>(self, compare: F) -> Option<usize>
source§fn position_minmax(self) -> MinMaxResult<usize>
fn position_minmax(self) -> MinMaxResult<usize>
source§fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>
fn position_minmax_by_key<K, F>(self, key: F) -> MinMaxResult<usize>
source§fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>
fn position_minmax_by<F>(self, compare: F) -> MinMaxResult<usize>
source§fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
fn exactly_one(self) -> Result<Self::Item, ExactlyOneError<Self>>where
Self: Sized,
source§fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where
Self: Sized,
fn at_most_one(self) -> Result<Option<Self::Item>, ExactlyOneError<Self>>where
Self: Sized,
source§fn multipeek(self) -> MultiPeek<Self>where
Self: Sized,
fn multipeek(self) -> MultiPeek<Self>where
Self: Sized,
.next()
values without advancing the base iterator. Read moresource§fn counts(self) -> HashMap<Self::Item, usize>
fn counts(self) -> HashMap<Self::Item, usize>
HashMap which
contains each item that appears in the iterator and the number
of times it appears. Read moresource§fn counts_by<K, F>(self, f: F) -> HashMap<K, usize>
fn counts_by<K, F>(self, f: F) -> HashMap<K, usize>
HashMap which
contains each item that appears in the iterator and the number
of times it appears,
determining identity using a keying function. Read moresource§fn multiunzip<FromI>(self) -> FromIwhere
Self: Sized + MultiUnzip<FromI>,
fn multiunzip<FromI>(self) -> FromIwhere
Self: Sized + MultiUnzip<FromI>,
§impl<Sp> LocalSpawnExt for Spwhere
Sp: LocalSpawn + ?Sized,
impl<Sp> LocalSpawnExt for Spwhere
Sp: LocalSpawn + ?Sized,
§fn spawn_local<Fut>(&self, future: Fut) -> Result<(), SpawnError>
fn spawn_local<Fut>(&self, future: Fut) -> Result<(), SpawnError>
() to
completion. Read more§impl<T, M> MakeExt<T> for Mwhere
M: MakeVisitor<T> + Sealed<MakeExtMarker<T>>,
impl<T, M> MakeExt<T> for Mwhere
M: MakeVisitor<T> + Sealed<MakeExtMarker<T>>,
§fn debug_alt(self) -> Alt<Self>
fn debug_alt(self) -> Alt<Self>
self so that any fmt::Debug fields are recorded using the
alternate formatter ({:#?}).§fn display_messages(self) -> Messages<Self>
fn display_messages(self) -> Messages<Self>
self so that any string fields named “message” are recorded
using fmt::Display.§impl<M, S, Target, Request> MakeService<Target, Request> for Mwhere
M: Service<Target, Response = S>,
S: Service<Request>,
impl<M, S, Target, Request> MakeService<Target, Request> for Mwhere
M: Service<Target, Response = S>,
S: Service<Request>,
§fn poll_ready(
&mut self,
cx: &mut Context<'_>,
) -> Poll<Result<(), <M as MakeService<Target, Request>>::MakeError>>
fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <M as MakeService<Target, Request>>::MakeError>>
Poll::Ready when the factory is able to create more services. Read more§fn make_service(
&mut self,
target: Target,
) -> <M as MakeService<Target, Request>>::Future
fn make_service( &mut self, target: Target, ) -> <M as MakeService<Target, Request>>::Future
§fn into_service(self) -> IntoService<Self, Request>where
Self: Sized,
fn into_service(self) -> IntoService<Self, Request>where
Self: Sized,
§fn as_service(&mut self) -> AsService<'_, Self, Request>where
Self: Sized,
fn as_service(&mut self) -> AsService<'_, Self, Request>where
Self: Sized,
§impl<T, V, F> MakeVisitor<T> for Fwhere
F: Fn(T) -> V,
V: Visit,
impl<T, V, F> MakeVisitor<T> for Fwhere
F: Fn(T) -> V,
V: Visit,
§fn make_visitor(&self, target: T) -> <F as MakeVisitor<T>>::Visitor
fn make_visitor(&self, target: T) -> <F as MakeVisitor<T>>::Visitor
target.§impl<'a, F, W> MakeWriter<'a> for F
impl<'a, F, W> MakeWriter<'a> for F
§type Writer = W
type Writer = W
io::Write implementation returned by make_writer.§fn make_writer(&'a self) -> <F as MakeWriter<'a>>::Writer
fn make_writer(&'a self) -> <F as MakeWriter<'a>>::Writer
§fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer
fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer
§impl<'a, M> MakeWriterExt<'a> for Mwhere
M: MakeWriter<'a>,
impl<'a, M> MakeWriterExt<'a> for Mwhere
M: MakeWriter<'a>,
§fn with_max_level(self, level: Level) -> WithMaxLevel<Self>where
Self: Sized,
fn with_max_level(self, level: Level) -> WithMaxLevel<Self>where
Self: Sized,
§fn with_min_level(self, level: Level) -> WithMinLevel<Self>where
Self: Sized,
fn with_min_level(self, level: Level) -> WithMinLevel<Self>where
Self: Sized,
§fn with_filter<F>(self, filter: F) -> WithFilter<Self, F>
fn with_filter<F>(self, filter: F) -> WithFilter<Self, F>
§fn or_else<W, B>(self, other: B) -> OrElse<Self, B>
fn or_else<W, B>(self, other: B) -> OrElse<Self, B>
self with another type implementing [MakeWriter], returning
a new [MakeWriter] that calls other’s make_writer if self’s
make_writer returns OptionalWriter::none. Read more§impl<M, F> MetricConstructor<M> for Fwhere
F: Fn() -> M,
impl<M, F> MetricConstructor<M> for Fwhere
F: Fn() -> M,
§fn new_metric(&self) -> M
fn new_metric(&self) -> M
§impl<F> Middleware for F
impl<F> Middleware for F
source§impl<IT> MultiUnzip<()> for IT
impl<IT> MultiUnzip<()> for IT
source§fn multiunzip(self)
fn multiunzip(self)
source§impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
source§fn multiunzip(self) -> (FromA,)
fn multiunzip(self) -> (FromA,)
source§impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
source§fn multiunzip(self) -> (FromA, FromB)
fn multiunzip(self) -> (FromA, FromB)
source§impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC)
fn multiunzip(self) -> (FromA, FromB, FromC)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
source§fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
source§fn multiunzip(
self,
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
fn multiunzip( self, ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
source§fn multiunzip(
self,
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)
fn multiunzip( self, ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
source§fn multiunzip(
self,
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)
fn multiunzip( self, ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)
source§impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ITwhere
IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
FromC: Default + Extend<C>,
FromD: Default + Extend<D>,
FromE: Default + Extend<E>,
FromF: Default + Extend<F>,
FromG: Default + Extend<G>,
FromH: Default + Extend<H>,
FromI: Default + Extend<I>,
FromJ: Default + Extend<J>,
FromK: Default + Extend<K>,
FromL: Default + Extend<L>,
source§fn multiunzip(
self,
) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)
fn multiunzip( self, ) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)
§impl<E, F> Notify<E> for F
impl<E, F> Notify<E> for F
§impl<S, T> ParallelSlice<T> for S
impl<S, T> ParallelSlice<T> for S
§fn par_chunk_map<F, R>(
&self,
task_pool: &TaskPool,
chunk_size: usize,
f: F,
) -> Vec<R>
fn par_chunk_map<F, R>( &self, task_pool: &TaskPool, chunk_size: usize, f: F, ) -> Vec<R>
chunks_size or less and maps the chunks
in parallel across the provided task_pool. One task is spawned in the task pool
for every chunk. Read more§impl<S, T> ParallelSliceMut<T> for S
impl<S, T> ParallelSliceMut<T> for S
§fn par_chunk_map_mut<F, R>(
&mut self,
task_pool: &TaskPool,
chunk_size: usize,
f: F,
) -> Vec<R>
fn par_chunk_map_mut<F, R>( &mut self, task_pool: &TaskPool, chunk_size: usize, f: F, ) -> Vec<R>
chunks_size or less and maps the chunks
in parallel across the provided task_pool. One task is spawned in the task pool
for every chunk. Read more§impl<'a, I, O, E, F> Parser<I, O, E> for F
impl<'a, I, O, E, F> Parser<I, O, E> for F
§fn parse(&mut self, i: I) -> Result<(I, O), Err<E>>
fn parse(&mut self, i: I) -> Result<(I, O), Err<E>>
Result containing
either the remaining input and the output value, or an error§fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O>
fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O>
§fn and_then<G, O2>(self, g: G) -> AndThen<Self, G, O>where
G: Parser<O, O2, E>,
Self: Sized,
fn and_then<G, O2>(self, g: G) -> AndThen<Self, G, O>where
G: Parser<O, O2, E>,
Self: Sized,
§fn and<G, O2>(self, g: G) -> And<Self, G>where
G: Parser<I, O2, E>,
Self: Sized,
fn and<G, O2>(self, g: G) -> And<Self, G>where
G: Parser<I, O2, E>,
Self: Sized,
§impl<Iter> PathIterator for Iter
impl<Iter> PathIterator for Iter
source§impl<'a, F> Pattern<'a> for F
impl<'a, F> Pattern<'a> for F
§type Searcher = CharPredicateSearcher<'a, F>
type Searcher = CharPredicateSearcher<'a, F>
pattern)source§fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>
fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>
pattern)self and the haystack to search in.source§fn is_contained_in(self, haystack: &'a str) -> bool
fn is_contained_in(self, haystack: &'a str) -> bool
pattern)source§fn is_prefix_of(self, haystack: &'a str) -> bool
fn is_prefix_of(self, haystack: &'a str) -> bool
pattern)source§fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
pattern)source§fn is_suffix_of(self, haystack: &'a str) -> boolwhere
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,
fn is_suffix_of(self, haystack: &'a str) -> boolwhere
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,
pattern)source§fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,
pattern)§impl<Cb> Pattern for Cb
impl<Cb> Pattern for Cb
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self, then passes self.as_ref() into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self, then passes self.as_mut() into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self, then passes self.deref() into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<LeafData, F> QbvhDataGenerator<LeafData> for Fwhere
F: ExactSizeIterator<Item = (LeafData, Aabb)>,
impl<LeafData, F> QbvhDataGenerator<LeafData> for Fwhere
F: ExactSizeIterator<Item = (LeafData, Aabb)>,
§impl<T> RawDefault for Twhere
T: Default,
impl<T> RawDefault for Twhere
T: Default,
§impl<R> ReadBytesExt for R
impl<R> ReadBytesExt for R
§fn read_u8(&mut self) -> Result<u8, Error>
fn read_u8(&mut self) -> Result<u8, Error>
§fn read_i8(&mut self) -> Result<i8, Error>
fn read_i8(&mut self) -> Result<i8, Error>
§fn read_u16<T>(&mut self) -> Result<u16, Error>where
T: ByteOrder,
fn read_u16<T>(&mut self) -> Result<u16, Error>where
T: ByteOrder,
§fn read_i16<T>(&mut self) -> Result<i16, Error>where
T: ByteOrder,
fn read_i16<T>(&mut self) -> Result<i16, Error>where
T: ByteOrder,
§fn read_u24<T>(&mut self) -> Result<u32, Error>where
T: ByteOrder,
fn read_u24<T>(&mut self) -> Result<u32, Error>where
T: ByteOrder,
§fn read_i24<T>(&mut self) -> Result<i32, Error>where
T: ByteOrder,
fn read_i24<T>(&mut self) -> Result<i32, Error>where
T: ByteOrder,
§fn read_u32<T>(&mut self) -> Result<u32, Error>where
T: ByteOrder,
fn read_u32<T>(&mut self) -> Result<u32, Error>where
T: ByteOrder,
§fn read_i32<T>(&mut self) -> Result<i32, Error>where
T: ByteOrder,
fn read_i32<T>(&mut self) -> Result<i32, Error>where
T: ByteOrder,
§fn read_u48<T>(&mut self) -> Result<u64, Error>where
T: ByteOrder,
fn read_u48<T>(&mut self) -> Result<u64, Error>where
T: ByteOrder,
§fn read_i48<T>(&mut self) -> Result<i64, Error>where
T: ByteOrder,
fn read_i48<T>(&mut self) -> Result<i64, Error>where
T: ByteOrder,
§fn read_u64<T>(&mut self) -> Result<u64, Error>where
T: ByteOrder,
fn read_u64<T>(&mut self) -> Result<u64, Error>where
T: ByteOrder,
§fn read_i64<T>(&mut self) -> Result<i64, Error>where
T: ByteOrder,
fn read_i64<T>(&mut self) -> Result<i64, Error>where
T: ByteOrder,
§fn read_u128<T>(&mut self) -> Result<u128, Error>where
T: ByteOrder,
fn read_u128<T>(&mut self) -> Result<u128, Error>where
T: ByteOrder,
§fn read_i128<T>(&mut self) -> Result<i128, Error>where
T: ByteOrder,
fn read_i128<T>(&mut self) -> Result<i128, Error>where
T: ByteOrder,
§fn read_uint<T>(&mut self, nbytes: usize) -> Result<u64, Error>where
T: ByteOrder,
fn read_uint<T>(&mut self, nbytes: usize) -> Result<u64, Error>where
T: ByteOrder,
§fn read_int<T>(&mut self, nbytes: usize) -> Result<i64, Error>where
T: ByteOrder,
fn read_int<T>(&mut self, nbytes: usize) -> Result<i64, Error>where
T: ByteOrder,
§fn read_uint128<T>(&mut self, nbytes: usize) -> Result<u128, Error>where
T: ByteOrder,
fn read_uint128<T>(&mut self, nbytes: usize) -> Result<u128, Error>where
T: ByteOrder,
§fn read_int128<T>(&mut self, nbytes: usize) -> Result<i128, Error>where
T: ByteOrder,
fn read_int128<T>(&mut self, nbytes: usize) -> Result<i128, Error>where
T: ByteOrder,
§fn read_f32<T>(&mut self) -> Result<f32, Error>where
T: ByteOrder,
fn read_f32<T>(&mut self) -> Result<f32, Error>where
T: ByteOrder,
§fn read_f64<T>(&mut self) -> Result<f64, Error>where
T: ByteOrder,
fn read_f64<T>(&mut self) -> Result<f64, Error>where
T: ByteOrder,
§fn read_u16_into<T>(&mut self, dst: &mut [u16]) -> Result<(), Error>where
T: ByteOrder,
fn read_u16_into<T>(&mut self, dst: &mut [u16]) -> Result<(), Error>where
T: ByteOrder,
§fn read_u32_into<T>(&mut self, dst: &mut [u32]) -> Result<(), Error>where
T: ByteOrder,
fn read_u32_into<T>(&mut self, dst: &mut [u32]) -> Result<(), Error>where
T: ByteOrder,
§fn read_u64_into<T>(&mut self, dst: &mut [u64]) -> Result<(), Error>where
T: ByteOrder,
fn read_u64_into<T>(&mut self, dst: &mut [u64]) -> Result<(), Error>where
T: ByteOrder,
§fn read_u128_into<T>(&mut self, dst: &mut [u128]) -> Result<(), Error>where
T: ByteOrder,
fn read_u128_into<T>(&mut self, dst: &mut [u128]) -> Result<(), Error>where
T: ByteOrder,
§fn read_i8_into(&mut self, dst: &mut [i8]) -> Result<(), Error>
fn read_i8_into(&mut self, dst: &mut [i8]) -> Result<(), Error>
§fn read_i16_into<T>(&mut self, dst: &mut [i16]) -> Result<(), Error>where
T: ByteOrder,
fn read_i16_into<T>(&mut self, dst: &mut [i16]) -> Result<(), Error>where
T: ByteOrder,
§fn read_i32_into<T>(&mut self, dst: &mut [i32]) -> Result<(), Error>where
T: ByteOrder,
fn read_i32_into<T>(&mut self, dst: &mut [i32]) -> Result<(), Error>where
T: ByteOrder,
§fn read_i64_into<T>(&mut self, dst: &mut [i64]) -> Result<(), Error>where
T: ByteOrder,
fn read_i64_into<T>(&mut self, dst: &mut [i64]) -> Result<(), Error>where
T: ByteOrder,
§fn read_i128_into<T>(&mut self, dst: &mut [i128]) -> Result<(), Error>where
T: ByteOrder,
fn read_i128_into<T>(&mut self, dst: &mut [i128]) -> Result<(), Error>where
T: ByteOrder,
§fn read_f32_into<T>(&mut self, dst: &mut [f32]) -> Result<(), Error>where
T: ByteOrder,
fn read_f32_into<T>(&mut self, dst: &mut [f32]) -> Result<(), Error>where
T: ByteOrder,
§fn read_f32_into_unchecked<T>(&mut self, dst: &mut [f32]) -> Result<(), Error>where
T: ByteOrder,
fn read_f32_into_unchecked<T>(&mut self, dst: &mut [f32]) -> Result<(), Error>where
T: ByteOrder,
read_f32_into instead§impl<R> ReadBytesExt for R
impl<R> ReadBytesExt for R
§fn read_u8(&mut self) -> Result<u8, Error>
fn read_u8(&mut self) -> Result<u8, Error>
§fn read_i8(&mut self) -> Result<i8, Error>
fn read_i8(&mut self) -> Result<i8, Error>
§fn read_u16<T>(&mut self) -> Result<u16, Error>where
T: ByteOrder,
fn read_u16<T>(&mut self) -> Result<u16, Error>where
T: ByteOrder,
§fn read_i16<T>(&mut self) -> Result<i16, Error>where
T: ByteOrder,
fn read_i16<T>(&mut self) -> Result<i16, Error>where
T: ByteOrder,
§fn read_u24<T>(&mut self) -> Result<u32, Error>where
T: ByteOrder,
fn read_u24<T>(&mut self) -> Result<u32, Error>where
T: ByteOrder,
§fn read_i24<T>(&mut self) -> Result<i32, Error>where
T: ByteOrder,
fn read_i24<T>(&mut self) -> Result<i32, Error>where
T: ByteOrder,
§fn read_u32<T>(&mut self) -> Result<u32, Error>where
T: ByteOrder,
fn read_u32<T>(&mut self) -> Result<u32, Error>where
T: ByteOrder,
§fn read_i32<T>(&mut self) -> Result<i32, Error>where
T: ByteOrder,
fn read_i32<T>(&mut self) -> Result<i32, Error>where
T: ByteOrder,
§fn read_u48<T>(&mut self) -> Result<u64, Error>where
T: ByteOrder,
fn read_u48<T>(&mut self) -> Result<u64, Error>where
T: ByteOrder,
§fn read_i48<T>(&mut self) -> Result<i64, Error>where
T: ByteOrder,
fn read_i48<T>(&mut self) -> Result<i64, Error>where
T: ByteOrder,
§fn read_u64<T>(&mut self) -> Result<u64, Error>where
T: ByteOrder,
fn read_u64<T>(&mut self) -> Result<u64, Error>where
T: ByteOrder,
§fn read_i64<T>(&mut self) -> Result<i64, Error>where
T: ByteOrder,
fn read_i64<T>(&mut self) -> Result<i64, Error>where
T: ByteOrder,
§fn read_u128<T>(&mut self) -> Result<u128, Error>where
T: ByteOrder,
fn read_u128<T>(&mut self) -> Result<u128, Error>where
T: ByteOrder,
§fn read_i128<T>(&mut self) -> Result<i128, Error>where
T: ByteOrder,
fn read_i128<T>(&mut self) -> Result<i128, Error>where
T: ByteOrder,
§fn read_uint<T>(&mut self, nbytes: usize) -> Result<u64, Error>where
T: ByteOrder,
fn read_uint<T>(&mut self, nbytes: usize) -> Result<u64, Error>where
T: ByteOrder,
§fn read_int<T>(&mut self, nbytes: usize) -> Result<i64, Error>where
T: ByteOrder,
fn read_int<T>(&mut self, nbytes: usize) -> Result<i64, Error>where
T: ByteOrder,
§fn read_uint128<T>(&mut self, nbytes: usize) -> Result<u128, Error>where
T: ByteOrder,
fn read_uint128<T>(&mut self, nbytes: usize) -> Result<u128, Error>where
T: ByteOrder,
§fn read_int128<T>(&mut self, nbytes: usize) -> Result<i128, Error>where
T: ByteOrder,
fn read_int128<T>(&mut self, nbytes: usize) -> Result<i128, Error>where
T: ByteOrder,
§impl<F, T> Replacer for F
impl<F, T> Replacer for F
§impl<F, T> Replacer for F
impl<F, T> Replacer for F
§fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String)
fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String)
dst to replace the current match. Read more§impl<F, E> ResolveServerName for F
impl<F, E> ResolveServerName for F
§impl<F> Resolver for F
impl<F> Resolver for F
source§impl<R> Rng for R
impl<R> Rng for R
source§fn gen<T>(&mut self) -> Twhere
Standard: Distribution<T>,
fn gen<T>(&mut self) -> Twhere
Standard: Distribution<T>,
source§fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
source§fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
source§fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T>where
D: Distribution<T>,
Self: Sized,
fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T>where
D: Distribution<T>,
Self: Sized,
source§fn gen_bool(&mut self, p: f64) -> bool
fn gen_bool(&mut self, p: f64) -> bool
p of being true. Read moresource§fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool
fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool
numerator/denominator of being
true. I.e. gen_ratio(2, 3) has chance of 2 in 3, or about 67%, of
returning true. If numerator == denominator, then the returned value
is guaranteed to be true. If numerator == 0, then the returned
value is guaranteed to be false. Read more§impl<F> ScanEventHandler for F
impl<F> ScanEventHandler for F
§fn handle_event(&mut self, event: Result<PathBuf, Error>)
fn handle_event(&mut self, event: Result<PathBuf, Error>)
source§impl<T> Serialize for T
impl<T> Serialize for T
fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<Ok, Error>
source§impl<T> Serialize for T
impl<T> Serialize for T
fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), Error>
fn do_erased_serialize( &self, serializer: &mut dyn Serializer, ) -> Result<(), ErrorImpl>
§impl<T, Request> ServiceExt<Request> for Twhere
T: Service<Request> + ?Sized,
impl<T, Request> ServiceExt<Request> for Twhere
T: Service<Request> + ?Sized,
§fn ready(&mut self) -> Ready<'_, Self, Request> ⓘwhere
Self: Sized,
fn ready(&mut self) -> Ready<'_, Self, Request> ⓘwhere
Self: Sized,
§fn ready_and(&mut self) -> Ready<'_, Self, Request> ⓘwhere
Self: Sized,
fn ready_and(&mut self) -> Ready<'_, Self, Request> ⓘwhere
Self: Sized,
ServiceExt::ready method instead§fn ready_oneshot(self) -> ReadyOneshot<Self, Request> ⓘwhere
Self: Sized,
fn ready_oneshot(self) -> ReadyOneshot<Self, Request> ⓘwhere
Self: Sized,
§fn oneshot(self, req: Request) -> Oneshot<Self, Request> ⓘwhere
Self: Sized,
fn oneshot(self, req: Request) -> Oneshot<Self, Request> ⓘwhere
Self: Sized,
Service, calling with the providing request once it is ready.§fn and_then<F>(self, f: F) -> AndThen<Self, F>
fn and_then<F>(self, f: F) -> AndThen<Self, F>
poll_ready method. Read more§fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F>
fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F>
poll_ready method. Read more§fn map_err<F, Error>(self, f: F) -> MapErr<Self, F>
fn map_err<F, Error>(self, f: F) -> MapErr<Self, F>
poll_ready method. Read more§fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F>
fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F>
Result<Self::Response, Self::Error>)
to a different value, regardless of whether the future succeeds or
fails. Read more§fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F>
fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F>
§fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F>
fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F>
§fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F>
fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F>
§impl<F> SessionPlugin for F
impl<F> SessionPlugin for F
source§impl<F, LeafData, SimdBV> SimdVisitor<LeafData, SimdBV> for F
impl<F, LeafData, SimdBV> SimdVisitor<LeafData, SimdBV> for F
§impl<T, Item> SinkExt<Item> for Twhere
T: Sink<Item> + ?Sized,
impl<T, Item> SinkExt<Item> for Twhere
T: Sink<Item> + ?Sized,
§fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F>
fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F>
§fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, Item, U, St, F>
fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, Item, U, St, F>
§fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F>
fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F>
§fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E>
fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E>
Into trait. Read more§fn buffer(self, capacity: usize) -> Buffer<Self, Item>where
Self: Sized,
fn buffer(self, capacity: usize) -> Buffer<Self, Item>where
Self: Sized,
§fn flush(&mut self) -> Flush<'_, Self, Item> ⓘwhere
Self: Unpin,
fn flush(&mut self) -> Flush<'_, Self, Item> ⓘwhere
Self: Unpin,
§fn send(&mut self, item: Item) -> Send<'_, Self, Item> ⓘwhere
Self: Unpin,
fn send(&mut self, item: Item) -> Send<'_, Self, Item> ⓘwhere
Self: Unpin,
§fn feed(&mut self, item: Item) -> Feed<'_, Self, Item> ⓘwhere
Self: Unpin,
fn feed(&mut self, item: Item) -> Feed<'_, Self, Item> ⓘwhere
Self: Unpin,
§fn send_all<'a, St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St> ⓘ
fn send_all<'a, St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St> ⓘ
§fn left_sink<Si2>(self) -> Either<Self, Si2> ⓘwhere
Si2: Sink<Item, Error = Self::Error>,
Self: Sized,
fn left_sink<Si2>(self) -> Either<Self, Si2> ⓘwhere
Si2: Sink<Item, Error = Self::Error>,
Self: Sized,
§fn right_sink<Si1>(self) -> Either<Si1, Self> ⓘwhere
Si1: Sink<Item, Error = Self::Error>,
Self: Sized,
fn right_sink<Si1>(self) -> Either<Si1, Self> ⓘwhere
Si1: Sink<Item, Error = Self::Error>,
Self: Sized,
§fn poll_ready_unpin(
&mut self,
cx: &mut Context<'_>,
) -> Poll<Result<(), Self::Error>>where
Self: Unpin,
fn poll_ready_unpin(
&mut self,
cx: &mut Context<'_>,
) -> Poll<Result<(), Self::Error>>where
Self: Unpin,
Sink::poll_ready] on Unpin
sink types.§fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error>where
Self: Unpin,
fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error>where
Self: Unpin,
Sink::start_send] on Unpin
sink types.§impl<Item, S> SinkRateLimitExt<Item, S> for Swhere
S: Sink<Item>,
impl<Item, S> SinkRateLimitExt<Item, S> for Swhere
S: Sink<Item>,
§fn ratelimit_sink<D, C, MW>(
self,
limiter: &RateLimiter<NotKeyed, D, C, MW>,
) -> RatelimitedSink<'_, Item, S, D, C, MW>where
D: DirectStateStore,
C: ReasonablyRealtime,
MW: RateLimitingMiddleware<<C as Clock>::Instant, NegativeOutcome = NotUntil<<C as Clock>::Instant>>,
fn ratelimit_sink<D, C, MW>(
self,
limiter: &RateLimiter<NotKeyed, D, C, MW>,
) -> RatelimitedSink<'_, Item, S, D, C, MW>where
D: DirectStateStore,
C: ReasonablyRealtime,
MW: RateLimitingMiddleware<<C as Clock>::Instant, NegativeOutcome = NotUntil<<C as Clock>::Instant>>,
§fn ratelimit_sink_with_jitter<D, C, MW>(
self,
limiter: &RateLimiter<NotKeyed, D, C, MW>,
jitter: Jitter,
) -> RatelimitedSink<'_, Item, S, D, C, MW>where
D: DirectStateStore,
C: ReasonablyRealtime,
MW: RateLimitingMiddleware<<C as Clock>::Instant, NegativeOutcome = NotUntil<<C as Clock>::Instant>>,
fn ratelimit_sink_with_jitter<D, C, MW>(
self,
limiter: &RateLimiter<NotKeyed, D, C, MW>,
jitter: Jitter,
) -> RatelimitedSink<'_, Item, S, D, C, MW>where
D: DirectStateStore,
C: ReasonablyRealtime,
MW: RateLimitingMiddleware<<C as Clock>::Instant, NegativeOutcome = NotUntil<<C as Clock>::Instant>>,
§impl<Sp> SpawnExt for Spwhere
Sp: Spawn + ?Sized,
impl<Sp> SpawnExt for Spwhere
Sp: Spawn + ?Sized,
§fn spawn<Fut>(&self, future: Fut) -> Result<(), SpawnError>
fn spawn<Fut>(&self, future: Fut) -> Result<(), SpawnError>
() to
completion. Read more§impl<S> StreamExt for S
impl<S> StreamExt for S
§fn next(&mut self) -> NextFuture<'_, Self> ⓘwhere
Self: Unpin,
fn next(&mut self) -> NextFuture<'_, Self> ⓘwhere
Self: Unpin,
§fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self> ⓘ
fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self> ⓘ
§fn count(self) -> CountFuture<Self> ⓘwhere
Self: Sized,
fn count(self) -> CountFuture<Self> ⓘwhere
Self: Sized,
§fn map<T, F>(self, f: F) -> Map<Self, F>
fn map<T, F>(self, f: F) -> Map<Self, F>
§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
§fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>
fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>
§fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>
§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n items of the stream. Read more§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n items of the stream. Read more§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
§fn chain<U>(self, other: U) -> Chain<Self, U>
fn chain<U>(self, other: U) -> Chain<Self, U>
§fn collect<C>(self) -> CollectFuture<Self, C> ⓘ
fn collect<C>(self) -> CollectFuture<Self, C> ⓘ
§fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> ⓘ
fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> ⓘ
§fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B> ⓘ
fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B> ⓘ
predicate is true and those for which it is
false, and then collects them into two collections. Read more§fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> ⓘ
fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> ⓘ
§fn try_fold<T, E, F, B>(
&mut self,
init: B,
f: F,
) -> TryFoldFuture<'_, Self, F, B> ⓘ
fn try_fold<T, E, F, B>( &mut self, init: B, f: F, ) -> TryFoldFuture<'_, Self, F, B> ⓘ
§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
(index, item). Read more§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
§fn nth(&mut self, n: usize) -> NthFuture<'_, Self> ⓘwhere
Self: Unpin,
fn nth(&mut self, n: usize) -> NthFuture<'_, Self> ⓘwhere
Self: Unpin,
nth item of the stream. Read more§fn last(self) -> LastFuture<Self> ⓘwhere
Self: Sized,
fn last(self) -> LastFuture<Self> ⓘwhere
Self: Sized,
§fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> ⓘ
fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> ⓘ
§fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> ⓘ
fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> ⓘ
§fn zip<U>(self, other: U) -> Zip<Self, U>
fn zip<U>(self, other: U) -> Zip<Self, U>
§fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> ⓘ
fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> ⓘ
§fn race<S>(self, other: S) -> Race<Self, S>
fn race<S>(self, other: S) -> Race<Self, S>
other stream, with no preference for either stream when both are ready. Read more§impl<S> StreamExt for S
impl<S> StreamExt for S
§fn next(&mut self) -> NextFuture<'_, Self> ⓘwhere
Self: Unpin,
fn next(&mut self) -> NextFuture<'_, Self> ⓘwhere
Self: Unpin,
§fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self> ⓘ
fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self> ⓘ
§fn count(self) -> CountFuture<Self> ⓘwhere
Self: Sized,
fn count(self) -> CountFuture<Self> ⓘwhere
Self: Sized,
§fn map<T, F>(self, f: F) -> Map<Self, F>
fn map<T, F>(self, f: F) -> Map<Self, F>
§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
§fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>
fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>
§fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>
§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n items of the stream. Read more§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n items of the stream. Read more§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
§fn chain<U>(self, other: U) -> Chain<Self, U>
fn chain<U>(self, other: U) -> Chain<Self, U>
§fn collect<C>(self) -> CollectFuture<Self, C> ⓘ
fn collect<C>(self) -> CollectFuture<Self, C> ⓘ
§fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> ⓘ
fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> ⓘ
§fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B> ⓘ
fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B> ⓘ
predicate is true and those for which it is
false, and then collects them into two collections. Read more§fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> ⓘ
fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> ⓘ
§fn try_fold<T, E, F, B>(
&mut self,
init: B,
f: F,
) -> TryFoldFuture<'_, Self, F, B> ⓘ
fn try_fold<T, E, F, B>( &mut self, init: B, f: F, ) -> TryFoldFuture<'_, Self, F, B> ⓘ
§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
(index, item). Read more§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
§fn nth(&mut self, n: usize) -> NthFuture<'_, Self> ⓘwhere
Self: Unpin,
fn nth(&mut self, n: usize) -> NthFuture<'_, Self> ⓘwhere
Self: Unpin,
nth item of the stream. Read more§fn last(self) -> LastFuture<Self> ⓘwhere
Self: Sized,
fn last(self) -> LastFuture<Self> ⓘwhere
Self: Sized,
§fn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P> ⓘ
fn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P> ⓘ
§fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F> ⓘ
fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F> ⓘ
§fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P> ⓘ
fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P> ⓘ
§fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> ⓘ
fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> ⓘ
§fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> ⓘ
fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> ⓘ
§fn zip<U>(self, other: U) -> Zip<Self, U>
fn zip<U>(self, other: U) -> Zip<Self, U>
§fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> ⓘ
fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> ⓘ
§fn race<S>(self, other: S) -> Race<Self, S>
fn race<S>(self, other: S) -> Race<Self, S>
other stream, with no preference for either stream when both are ready. Read more§fn drain(&mut self) -> Drain<'_, Self>
fn drain(&mut self) -> Drain<'_, Self>
§impl<S1> StreamExt for S1where
S1: Stream,
impl<S1> StreamExt for S1where
S1: Stream,
§fn merge<T, S2>(
self,
other: S2,
) -> Merge2<T, S1, <S2 as IntoStream>::IntoStream>where
S1: Stream<Item = T>,
S2: IntoStream<Item = T>,
fn merge<T, S2>(
self,
other: S2,
) -> Merge2<T, S1, <S2 as IntoStream>::IntoStream>where
S1: Stream<Item = T>,
S2: IntoStream<Item = T>,
§fn chain<T, S2>(self, other: S2) -> Chain2<S1, <S2 as IntoStream>::IntoStream>where
S1: Stream<Item = T>,
S2: IntoStream<Item = T>,
fn chain<T, S2>(self, other: S2) -> Chain2<S1, <S2 as IntoStream>::IntoStream>where
S1: Stream<Item = T>,
S2: IntoStream<Item = T>,
§fn zip<T, S2>(self, other: S2) -> Zip2<S1, <S2 as IntoStream>::IntoStream>where
S1: Stream<Item = T>,
S2: IntoStream<Item = T>,
fn zip<T, S2>(self, other: S2) -> Zip2<S1, <S2 as IntoStream>::IntoStream>where
S1: Stream<Item = T>,
S2: IntoStream<Item = T>,
§fn wait_until<D>(
self,
deadline: D,
) -> WaitUntil<Self, <D as IntoFuture>::IntoFuture>where
Self: Sized,
D: IntoFuture,
fn wait_until<D>(
self,
deadline: D,
) -> WaitUntil<Self, <D as IntoFuture>::IntoFuture>where
Self: Sized,
D: IntoFuture,
§impl<T> StreamExt for T
impl<T> StreamExt for T
§fn next(&mut self) -> Next<'_, Self> ⓘwhere
Self: Unpin,
fn next(&mut self) -> Next<'_, Self> ⓘwhere
Self: Unpin,
§fn into_future(self) -> StreamFuture<Self> ⓘ
fn into_future(self) -> StreamFuture<Self> ⓘ
§fn map<T, F>(self, f: F) -> Map<Self, F>
fn map<T, F>(self, f: F) -> Map<Self, F>
§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
§fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>
§fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>
§fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>
§fn collect<C>(self) -> Collect<Self, C> ⓘ
fn collect<C>(self) -> Collect<Self, C> ⓘ
§fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> ⓘ
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> ⓘ
§fn concat(self) -> Concat<Self> ⓘ
fn concat(self) -> Concat<Self> ⓘ
§fn count(self) -> Count<Self> ⓘwhere
Self: Sized,
fn count(self) -> Count<Self> ⓘwhere
Self: Sized,
§fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> ⓘ
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> ⓘ
§fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> ⓘ
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> ⓘ
true if any element in stream satisfied a predicate. Read more§fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> ⓘ
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> ⓘ
true if all element in stream satisfied a predicate. Read more§fn flatten(self) -> Flatten<Self>
fn flatten(self) -> Flatten<Self>
§fn flatten_unordered(
self,
limit: impl Into<Option<usize>>,
) -> FlattenUnorderedWithFlowController<Self, ()>
fn flatten_unordered( self, limit: impl Into<Option<usize>>, ) -> FlattenUnorderedWithFlowController<Self, ()>
§fn flat_map_unordered<U, F>(
self,
limit: impl Into<Option<usize>>,
f: F,
) -> FlatMapUnordered<Self, U, F>
fn flat_map_unordered<U, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> FlatMapUnordered<Self, U, F>
StreamExt::map] but flattens nested Streams
and polls them concurrently, yielding items in any order, as they made
available. Read more§fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>
StreamExt::fold] that holds internal state
and produces a new stream. Read more§fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>
true. Read more§fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>
true. Read more§fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>
§fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> ⓘ
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> ⓘ
§fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F,
) -> ForEachConcurrent<Self, Fut, F> ⓘ
fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> ForEachConcurrent<Self, Fut, F> ⓘ
§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n items of the underlying stream. Read more§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n items of the underlying stream. Read more§fn catch_unwind(self) -> CatchUnwind<Self>where
Self: Sized + UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self>where
Self: Sized + UnwindSafe,
§fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>
fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>
§fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>where
Self: Sized + 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>where
Self: Sized + 'a,
§fn buffered(self, n: usize) -> Buffered<Self>
fn buffered(self, n: usize) -> Buffered<Self>
§fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>
§fn peekable(self) -> Peekable<Self>where
Self: Sized,
fn peekable(self) -> Peekable<Self>where
Self: Sized,
peek method. Read more§fn chunks(self, capacity: usize) -> Chunks<Self>where
Self: Sized,
fn chunks(self, capacity: usize) -> Chunks<Self>where
Self: Sized,
§fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where
Self: Sized,
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where
Self: Sized,
§fn forward<S>(self, sink: S) -> Forward<Self, S> ⓘwhere
S: Sink<Self::Ok, Error = Self::Error>,
Self: Sized + TryStream,
fn forward<S>(self, sink: S) -> Forward<Self, S> ⓘwhere
S: Sink<Self::Ok, Error = Self::Error>,
Self: Sized + TryStream,
§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
§fn left_stream<B>(self) -> Either<Self, B> ⓘ
fn left_stream<B>(self) -> Either<Self, B> ⓘ
§fn right_stream<B>(self) -> Either<B, Self> ⓘ
fn right_stream<B>(self) -> Either<B, Self> ⓘ
§fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where
Self: Unpin,
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where
Self: Unpin,
Stream::poll_next on Unpin
stream types.§impl<'a, S> StreamRateLimitExt<'a> for Swhere
S: Stream,
impl<'a, S> StreamRateLimitExt<'a> for Swhere
S: Stream,
§fn ratelimit_stream<D, C, MW>(
self,
limiter: &'a RateLimiter<NotKeyed, D, C, MW>,
) -> RatelimitedStream<'a, S, D, C, MW>where
D: DirectStateStore,
C: Clock + ReasonablyRealtime,
MW: RateLimitingMiddleware<<C as Clock>::Instant>,
fn ratelimit_stream<D, C, MW>(
self,
limiter: &'a RateLimiter<NotKeyed, D, C, MW>,
) -> RatelimitedStream<'a, S, D, C, MW>where
D: DirectStateStore,
C: Clock + ReasonablyRealtime,
MW: RateLimitingMiddleware<<C as Clock>::Instant>,
§fn ratelimit_stream_with_jitter<D, C, MW>(
self,
limiter: &'a RateLimiter<NotKeyed, D, C, MW>,
jitter: Jitter,
) -> RatelimitedStream<'a, S, D, C, MW>where
D: DirectStateStore,
C: Clock + ReasonablyRealtime,
MW: RateLimitingMiddleware<<C as Clock>::Instant>,
fn ratelimit_stream_with_jitter<D, C, MW>(
self,
limiter: &'a RateLimiter<NotKeyed, D, C, MW>,
jitter: Jitter,
) -> RatelimitedStream<'a, S, D, C, MW>where
D: DirectStateStore,
C: Clock + ReasonablyRealtime,
MW: RateLimitingMiddleware<<C as Clock>::Instant>,
§impl<F, OutputVertex> StrokeVertexConstructor<OutputVertex> for Fwhere
F: Fn(StrokeVertex<'_, '_>) -> OutputVertex,
impl<F, OutputVertex> StrokeVertexConstructor<OutputVertex> for Fwhere
F: Fn(StrokeVertex<'_, '_>) -> OutputVertex,
fn new_vertex(&mut self, vertex: StrokeVertex<'_, '_>) -> OutputVertex
§impl<S> SubscriberExt for Swhere
S: Subscriber,
impl<S> SubscriberExt for Swhere
S: Subscriber,
§impl<T> SubscriberInitExt for Twhere
T: Into<Dispatch>,
impl<T> SubscriberInitExt for Twhere
T: Into<Dispatch>,
§fn set_default(self) -> DefaultGuard
fn set_default(self) -> DefaultGuard
self as the default subscriber in the current scope, returning a
guard that will unset it when dropped. Read more§fn try_init(self) -> Result<(), TryInitError>
fn try_init(self) -> Result<(), TryInitError>
self as the global default subscriber in the current
scope, returning an error if one is already set. Read more§fn init(self)
fn init(self)
self as the global default subscriber in the current
scope, panicking if this fails. Read more§impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
§fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self from the equivalent element of its
superset. Read more§fn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self is actually part of its subset T (and can be converted to it).§fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
self.to_subset but without any property checks. Always succeeds.§fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self to the equivalent element of its superset.§impl<Out, Func> SystemParamFunction<fn() -> Out> for Funcwhere
Func: Send + Sync + 'static,
&'a mut Func: for<'a> FnMut() -> Out + for<'a> FnMut(),
Out: 'static,
impl<Out, Func> SystemParamFunction<fn() -> Out> for Funcwhere
Func: Send + Sync + 'static,
&'a mut Func: for<'a> FnMut() -> Out + for<'a> FnMut(),
Out: 'static,
§impl<Out, Func, F0> SystemParamFunction<fn(_: F0) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
&'a mut Func: for<'a> FnMut(F0) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0> SystemParamFunction<fn(_: F0) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
&'a mut Func: for<'a> FnMut(F0) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>),
Out: 'static,
§impl<Out, Func, F0, F1> SystemParamFunction<fn(_: F0, _: F1) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1> SystemParamFunction<fn(_: F0, _: F1) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>),
Out: 'static,
§impl<Out, Func, F0, F1, F2> SystemParamFunction<fn(_: F0, _: F1, _: F2) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2> SystemParamFunction<fn(_: F0, _: F1, _: F2) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2)
type Param = (F0, F1, F2)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3)
type Param = (F0, F1, F2, F3)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4)
type Param = (F0, F1, F2, F3, F4)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5)
type Param = (F0, F1, F2, F3, F4, F5)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6)
type Param = (F0, F1, F2, F3, F4, F5, F6)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
F14: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>, <F14 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
F14: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>, <F14 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14, _: F15) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
F14: SystemParam,
F15: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>, <F14 as SystemParam>::Item<'_, '_>, <F15 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15> SystemParamFunction<fn(_: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14, _: F15) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
F14: SystemParam,
F15: SystemParam,
&'a mut Func: for<'a> FnMut(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) -> Out + for<'a> FnMut(<F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>, <F14 as SystemParam>::Item<'_, '_>, <F15 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
_input: (),
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, _input: (), param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func> SystemParamFunction<fn(_: In<Input>) -> Out> for Funcwhere
Func: Send + Sync + 'static,
&'a mut Func: for<'a> FnMut(In<Input>) -> Out + for<'a> FnMut(In<Input>),
Out: 'static,
impl<Input, Out, Func> SystemParamFunction<fn(_: In<Input>) -> Out> for Funcwhere
Func: Send + Sync + 'static,
&'a mut Func: for<'a> FnMut(In<Input>) -> Out + for<'a> FnMut(In<Input>),
Out: 'static,
§impl<Input, Out, Func, F0> SystemParamFunction<fn(_: In<Input>, _: F0) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0> SystemParamFunction<fn(_: In<Input>, _: F0) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>),
Out: 'static,
§impl<Input, Out, Func, F0, F1> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>),
Out: 'static,
§impl<Input, Out, Func, F0, F1, F2> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2)
type Param = (F0, F1, F2)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3)
type Param = (F0, F1, F2, F3)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4)
type Param = (F0, F1, F2, F3, F4)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5)
type Param = (F0, F1, F2, F3, F4, F5)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6)
type Param = (F0, F1, F2, F3, F4, F5, F6)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
F14: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>, <F14 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
F14: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>, <F14 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14, _: F15) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
F14: SystemParam,
F15: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>, <F14 as SystemParam>::Item<'_, '_>, <F15 as SystemParam>::Item<'_, '_>),
Out: 'static,
impl<Input, Out, Func, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15> SystemParamFunction<fn(_: In<Input>, _: F0, _: F1, _: F2, _: F3, _: F4, _: F5, _: F6, _: F7, _: F8, _: F9, _: F10, _: F11, _: F12, _: F13, _: F14, _: F15) -> Out> for Funcwhere
Func: Send + Sync + 'static,
F0: SystemParam,
F1: SystemParam,
F2: SystemParam,
F3: SystemParam,
F4: SystemParam,
F5: SystemParam,
F6: SystemParam,
F7: SystemParam,
F8: SystemParam,
F9: SystemParam,
F10: SystemParam,
F11: SystemParam,
F12: SystemParam,
F13: SystemParam,
F14: SystemParam,
F15: SystemParam,
&'a mut Func: for<'a> FnMut(In<Input>, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) -> Out + for<'a> FnMut(In<Input>, <F0 as SystemParam>::Item<'_, '_>, <F1 as SystemParam>::Item<'_, '_>, <F2 as SystemParam>::Item<'_, '_>, <F3 as SystemParam>::Item<'_, '_>, <F4 as SystemParam>::Item<'_, '_>, <F5 as SystemParam>::Item<'_, '_>, <F6 as SystemParam>::Item<'_, '_>, <F7 as SystemParam>::Item<'_, '_>, <F8 as SystemParam>::Item<'_, '_>, <F9 as SystemParam>::Item<'_, '_>, <F10 as SystemParam>::Item<'_, '_>, <F11 as SystemParam>::Item<'_, '_>, <F12 as SystemParam>::Item<'_, '_>, <F13 as SystemParam>::Item<'_, '_>, <F14 as SystemParam>::Item<'_, '_>, <F15 as SystemParam>::Item<'_, '_>),
Out: 'static,
§type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
type Param = (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
SystemParam]/s used by this system to access the [World].§fn run(
&mut self,
input: Input,
param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) as SystemParam>::Item<'_, '_>,
) -> Out
fn run( &mut self, input: Input, param_value: <(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15) as SystemParam>::Item<'_, '_>, ) -> Out
System::run] or [System::run_unsafe].§impl<T> Tagged for Twhere
T: FixedTag,
impl<T> Tagged for Twhere
T: FixedTag,
§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B> of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B> of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R> view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R> view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap() only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut() only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow() only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut() only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref() only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut() only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref() only in debug builds, and is erased in release
builds.source§impl<T> ToHex for T
impl<T> ToHex for T
source§fn encode_hex<U>(&self) -> Uwhere
U: FromIterator<char>,
fn encode_hex<U>(&self) -> Uwhere
U: FromIterator<char>,
self into the result. Lower case
letters are used (e.g. f9b4ca)source§fn encode_hex_upper<U>(&self) -> Uwhere
U: FromIterator<char>,
fn encode_hex_upper<U>(&self) -> Uwhere
U: FromIterator<char>,
self into the result. Upper case
letters are used (e.g. F9B4CA)§impl<T, U> ToSample<U> for Twhere
U: FromSample<T>,
impl<T, U> ToSample<U> for Twhere
U: FromSample<T>,
fn to_sample_(self) -> U
§impl<T> ToSmolStr for T
impl<T> ToSmolStr for T
fn to_smolstr(&self) -> SmolStr
§impl<T> TryConv for T
impl<T> TryConv for T
§impl<F, T, E> TryFuture for F
impl<F, T, E> TryFuture for F
§impl<T, E, F> TryFuture for F
impl<T, E, F> TryFuture for F
§impl<Fut> TryFutureExt for Futwhere
Fut: TryFuture + ?Sized,
impl<Fut> TryFutureExt for Futwhere
Fut: TryFuture + ?Sized,
§fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok>where
Self::Ok: Sink<Item, Error = Self::Error>,
Self: Sized,
fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok>where
Self::Ok: Sink<Item, Error = Self::Error>,
Self: Sized,
Sink]. Read more§fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> ⓘ
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> ⓘ
§fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E> ⓘ
fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E> ⓘ
§fn map_err<E, F>(self, f: F) -> MapErr<Self, F> ⓘ
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> ⓘ
§fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> ⓘ
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> ⓘ
§fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> ⓘ
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> ⓘ
§fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> ⓘ
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> ⓘ
§fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> ⓘ
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> ⓘ
§fn try_flatten(self) -> TryFlatten<Self, Self::Ok> ⓘwhere
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
fn try_flatten(self) -> TryFlatten<Self, Self::Ok> ⓘwhere
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
§fn try_flatten_stream(self) -> TryFlattenStream<Self>where
Self::Ok: TryStream<Error = Self::Error>,
Self: Sized,
fn try_flatten_stream(self) -> TryFlattenStream<Self>where
Self::Ok: TryStream<Error = Self::Error>,
Self: Sized,
§fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> ⓘ
fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> ⓘ
§fn into_future(self) -> IntoFuture<Self> ⓘwhere
Self: Sized,
fn into_future(self) -> IntoFuture<Self> ⓘwhere
Self: Sized,
§impl<S, T, E> TryStream for S
impl<S, T, E> TryStream for S
§impl<T, E, S> TryStream for S
impl<T, E, S> TryStream for S
§impl<S> TryStreamExt for Swhere
S: TryStream + ?Sized,
impl<S> TryStreamExt for Swhere
S: TryStream + ?Sized,
§fn err_into<E>(self) -> ErrInto<Self, E>
fn err_into<E>(self) -> ErrInto<Self, E>
§fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>
§fn map_err<E, F>(self, f: F) -> MapErr<Self, F>
fn map_err<E, F>(self, f: F) -> MapErr<Self, F>
§fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>
f. Read more§fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>
f. Read more§fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>
§fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>
§fn into_stream(self) -> IntoStream<Self>where
Self: Sized,
fn into_stream(self) -> IntoStream<Self>where
Self: Sized,
§fn try_next(&mut self) -> TryNext<'_, Self> ⓘwhere
Self: Unpin,
fn try_next(&mut self) -> TryNext<'_, Self> ⓘwhere
Self: Unpin,
§fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> ⓘ
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> ⓘ
§fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F>
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F>
true. Read more§fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F>
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F>
true. Read more§fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F,
) -> TryForEachConcurrent<Self, Fut, F> ⓘ
fn try_for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> TryForEachConcurrent<Self, Fut, F> ⓘ
§fn try_collect<C>(self) -> TryCollect<Self, C> ⓘ
fn try_collect<C>(self) -> TryCollect<Self, C> ⓘ
§fn try_chunks(self, capacity: usize) -> TryChunks<Self>where
Self: Sized,
fn try_chunks(self, capacity: usize) -> TryChunks<Self>where
Self: Sized,
§fn try_ready_chunks(self, capacity: usize) -> TryReadyChunks<Self>where
Self: Sized,
fn try_ready_chunks(self, capacity: usize) -> TryReadyChunks<Self>where
Self: Sized,
§fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>
§fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F>
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F>
§fn try_flatten_unordered(
self,
limit: impl Into<Option<usize>>,
) -> TryFlattenUnordered<Self>
fn try_flatten_unordered( self, limit: impl Into<Option<usize>>, ) -> TryFlattenUnordered<Self>
§fn try_flatten(self) -> TryFlatten<Self>
fn try_flatten(self) -> TryFlatten<Self>
§fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> ⓘ
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> ⓘ
§fn try_concat(self) -> TryConcat<Self> ⓘ
fn try_concat(self) -> TryConcat<Self> ⓘ
§fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
§fn try_buffered(self, n: usize) -> TryBuffered<Self>where
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
fn try_buffered(self, n: usize) -> TryBuffered<Self>where
Self::Ok: TryFuture<Error = Self::Error>,
Self: Sized,
§fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>,
) -> Poll<Option<Result<Self::Ok, Self::Error>>>where
Self: Unpin,
fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>,
) -> Poll<Option<Result<Self::Ok, Self::Error>>>where
Self: Unpin,
TryStream::try_poll_next] on Unpin
stream types.§fn into_async_read(self) -> IntoAsyncRead<Self>
fn into_async_read(self) -> IntoAsyncRead<Self>
AsyncBufRead. Read more§fn try_all<Fut, F>(self, f: F) -> TryAll<Self, Fut, F> ⓘ
fn try_all<Fut, F>(self, f: F) -> TryAll<Self, Fut, F> ⓘ
Err is encountered or if an Ok item is found
that does not satisfy the predicate. Read more§impl<T> TurboRand for T
impl<T> TurboRand for T
§fn u128(&self, bounds: impl RangeBounds<u128>) -> u128
fn u128(&self, bounds: impl RangeBounds<u128>) -> u128
u128 within a given range bound. Read more§fn i128(&self, bounds: impl RangeBounds<i128>) -> i128
fn i128(&self, bounds: impl RangeBounds<i128>) -> i128
i128 within a given range bound. Read more§fn usize(&self, bounds: impl RangeBounds<usize>) -> usize
fn usize(&self, bounds: impl RangeBounds<usize>) -> usize
usize within a given range bound. Read more§fn isize(&self, bounds: impl RangeBounds<isize>) -> isize
fn isize(&self, bounds: impl RangeBounds<isize>) -> isize
isize within a given range bound. Read more§fn f32_normalized(&self) -> f32
fn f32_normalized(&self) -> f32
f32 value between -1.0 and 1.0.§fn f64_normalized(&self) -> f64
fn f64_normalized(&self) -> f64
f32 value between -1.0 and 1.0.§fn index(&self, bound: impl RangeBounds<usize>) -> usize
fn index(&self, bound: impl RangeBounds<usize>) -> usize
usize value for stable indexing across different
word size platforms.§fn chance(&self, rate: f64) -> bool
fn chance(&self, rate: f64) -> bool
rate represents
the chance to return a true value, with 0.0 being no
chance and 1.0 will always return true. Read more§fn sample<'a, T>(&self, list: &'a [T]) -> Option<&'a T>
fn sample<'a, T>(&self, list: &'a [T]) -> Option<&'a T>
§fn sample_iter<T>(&self, list: T) -> Option<<T as Iterator>::Item>where
T: Iterator,
fn sample_iter<T>(&self, list: T) -> Option<<T as Iterator>::Item>where
T: Iterator,
O(1) if the
iterator provides an accurate Iterator::size_hint to allow
for optimisations to kick in, else O(n) where n is the size
of the iterator. Read more§fn sample_mut<'a, T>(&self, list: &'a mut [T]) -> Option<&'a mut T>
fn sample_mut<'a, T>(&self, list: &'a mut [T]) -> Option<&'a mut T>
&mut item from a slice of values. Read more§fn sample_multiple<'a, T>(&self, list: &'a [T], amount: usize) -> Vec<&'a T>
fn sample_multiple<'a, T>(&self, list: &'a [T], amount: usize) -> Vec<&'a T>
§fn sample_multiple_mut<'a, T>(
&self,
list: &'a mut [T],
amount: usize,
) -> Vec<&'a mut T>
fn sample_multiple_mut<'a, T>( &self, list: &'a mut [T], amount: usize, ) -> Vec<&'a mut T>
§fn sample_multiple_iter<T>(
&self,
list: T,
amount: usize,
) -> Vec<<T as Iterator>::Item>where
T: Iterator,
fn sample_multiple_iter<T>(
&self,
list: T,
amount: usize,
) -> Vec<<T as Iterator>::Item>where
T: Iterator,
§fn weighted_sample<'a, T, F>(
&self,
list: &'a [T],
weight_sampler: F,
) -> Option<&'a T>
fn weighted_sample<'a, T, F>( &self, list: &'a [T], weight_sampler: F, ) -> Option<&'a T>
rate value for each randomly sampled item
to decide whether to return it or not. The returned f64 value must be between 0.0 and 1.0. Read more§fn weighted_sample_mut<'a, T, F>(
&self,
list: &'a mut [T],
weight_sampler: F,
) -> Option<&'a mut T>
fn weighted_sample_mut<'a, T, F>( &self, list: &'a mut [T], weight_sampler: F, ) -> Option<&'a mut T>
rate value for each randomly sampled item
to decide whether to return it or not. The returned f64 value must be between 0.0 and 1.0. Read more§fn partial_shuffle<'a, T>(
&self,
slice: &'a mut [T],
amount: usize,
) -> (&'a mut [T], &'a mut [T])
fn partial_shuffle<'a, T>( &self, slice: &'a mut [T], amount: usize, ) -> (&'a mut [T], &'a mut [T])
§fn alphabetic(&self) -> char
fn alphabetic(&self) -> char
char in ranges a-z and A-Z.§fn alphanumeric(&self) -> char
fn alphanumeric(&self) -> char
char in ranges a-z, A-Z and 0-9.§impl<T> TypeData for T
impl<T> TypeData for T
fn clone_type_data(&self) -> Box<dyn TypeData>
§impl<I> UnicodeNormalization<I> for I
impl<I> UnicodeNormalization<I> for I
§fn nfd(self) -> Decompositions<I>
fn nfd(self) -> Decompositions<I>
§fn nfkd(self) -> Decompositions<I>
fn nfkd(self) -> Decompositions<I>
§fn nfc(self) -> Recompositions<I>
fn nfc(self) -> Recompositions<I>
§fn nfkc(self) -> Recompositions<I>
fn nfkc(self) -> Recompositions<I>
§fn cjk_compat_variants(self) -> Replacements<I>
fn cjk_compat_variants(self) -> Replacements<I>
§fn stream_safe(self) -> StreamSafe<I>
fn stream_safe(self) -> StreamSafe<I>
§impl<F> Visit for F
impl<F> Visit for F
§fn record_debug(&mut self, field: &Field, value: &dyn Debug)
fn record_debug(&mut self, field: &Field, value: &dyn Debug)
fmt::Debug.§fn record_f64(&mut self, field: &Field, value: f64)
fn record_f64(&mut self, field: &Field, value: f64)
§fn record_i64(&mut self, field: &Field, value: i64)
fn record_i64(&mut self, field: &Field, value: i64)
§fn record_u64(&mut self, field: &Field, value: u64)
fn record_u64(&mut self, field: &Field, value: u64)
§fn record_i128(&mut self, field: &Field, value: i128)
fn record_i128(&mut self, field: &Field, value: i128)
§fn record_u128(&mut self, field: &Field, value: u128)
fn record_u128(&mut self, field: &Field, value: u128)
§fn record_bool(&mut self, field: &Field, value: bool)
fn record_bool(&mut self, field: &Field, value: bool)
§fn record_str(&mut self, field: &Field, value: &str)
fn record_str(&mut self, field: &Field, value: &str)
§fn record_error(&mut self, field: &Field, value: &(dyn Error + 'static))
fn record_error(&mut self, field: &Field, value: &(dyn Error + 'static))
Error. Read more